source: node_modules/postcss/lib/parser.js@ 2058e5c

Last change on this file since 2058e5c was 2058e5c, checked in by istevanoska <ilinastevanoska@…>, 6 months ago

Working / before login
  • Property mode set to 100644
File size: 14.5 KB
Line 
1'use strict'
2
3let AtRule = require('./at-rule')
4let Comment = require('./comment')
5let Declaration = require('./declaration')
6let Root = require('./root')
7let Rule = require('./rule')
8let tokenizer = require('./tokenize')
9
10const SAFE_COMMENT_NEIGHBOR = {
11 empty: true,
12 space: true
13}
14
15function findLastWithPosition(tokens) {
16 for (let i = tokens.length - 1; i >= 0; i--) {
17 let token = tokens[i]
18 let pos = token[3] || token[2]
19 if (pos) return pos
20 }
21}
22
23class Parser {
24 constructor(input) {
25 this.input = input
26
27 this.root = new Root()
28 this.current = this.root
29 this.spaces = ''
30 this.semicolon = false
31
32 this.createTokenizer()
33 this.root.source = { input, start: { column: 1, line: 1, offset: 0 } }
34 }
35
36 atrule(token) {
37 let node = new AtRule()
38 node.name = token[1].slice(1)
39 if (node.name === '') {
40 this.unnamedAtrule(node, token)
41 }
42 this.init(node, token[2])
43
44 let type
45 let prev
46 let shift
47 let last = false
48 let open = false
49 let params = []
50 let brackets = []
51
52 while (!this.tokenizer.endOfFile()) {
53 token = this.tokenizer.nextToken()
54 type = token[0]
55
56 if (type === '(' || type === '[') {
57 brackets.push(type === '(' ? ')' : ']')
58 } else if (type === '{' && brackets.length > 0) {
59 brackets.push('}')
60 } else if (type === brackets[brackets.length - 1]) {
61 brackets.pop()
62 }
63
64 if (brackets.length === 0) {
65 if (type === ';') {
66 node.source.end = this.getPosition(token[2])
67 node.source.end.offset++
68 this.semicolon = true
69 break
70 } else if (type === '{') {
71 open = true
72 break
73 } else if (type === '}') {
74 if (params.length > 0) {
75 shift = params.length - 1
76 prev = params[shift]
77 while (prev && prev[0] === 'space') {
78 prev = params[--shift]
79 }
80 if (prev) {
81 node.source.end = this.getPosition(prev[3] || prev[2])
82 node.source.end.offset++
83 }
84 }
85 this.end(token)
86 break
87 } else {
88 params.push(token)
89 }
90 } else {
91 params.push(token)
92 }
93
94 if (this.tokenizer.endOfFile()) {
95 last = true
96 break
97 }
98 }
99
100 node.raws.between = this.spacesAndCommentsFromEnd(params)
101 if (params.length) {
102 node.raws.afterName = this.spacesAndCommentsFromStart(params)
103 this.raw(node, 'params', params)
104 if (last) {
105 token = params[params.length - 1]
106 node.source.end = this.getPosition(token[3] || token[2])
107 node.source.end.offset++
108 this.spaces = node.raws.between
109 node.raws.between = ''
110 }
111 } else {
112 node.raws.afterName = ''
113 node.params = ''
114 }
115
116 if (open) {
117 node.nodes = []
118 this.current = node
119 }
120 }
121
122 checkMissedSemicolon(tokens) {
123 let colon = this.colon(tokens)
124 if (colon === false) return
125
126 let founded = 0
127 let token
128 for (let j = colon - 1; j >= 0; j--) {
129 token = tokens[j]
130 if (token[0] !== 'space') {
131 founded += 1
132 if (founded === 2) break
133 }
134 }
135 // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
136 // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
137 // And because we need it after that one we do +1 to get the next one.
138 throw this.input.error(
139 'Missed semicolon',
140 token[0] === 'word' ? token[3] + 1 : token[2]
141 )
142 }
143
144 colon(tokens) {
145 let brackets = 0
146 let prev, token, type
147 for (let [i, element] of tokens.entries()) {
148 token = element
149 type = token[0]
150
151 if (type === '(') {
152 brackets += 1
153 }
154 if (type === ')') {
155 brackets -= 1
156 }
157 if (brackets === 0 && type === ':') {
158 if (!prev) {
159 this.doubleColon(token)
160 } else if (prev[0] === 'word' && prev[1] === 'progid') {
161 continue
162 } else {
163 return i
164 }
165 }
166
167 prev = token
168 }
169 return false
170 }
171
172 comment(token) {
173 let node = new Comment()
174 this.init(node, token[2])
175 node.source.end = this.getPosition(token[3] || token[2])
176 node.source.end.offset++
177
178 let text = token[1].slice(2, -2)
179 if (/^\s*$/.test(text)) {
180 node.text = ''
181 node.raws.left = text
182 node.raws.right = ''
183 } else {
184 let match = text.match(/^(\s*)([^]*\S)(\s*)$/)
185 node.text = match[2]
186 node.raws.left = match[1]
187 node.raws.right = match[3]
188 }
189 }
190
191 createTokenizer() {
192 this.tokenizer = tokenizer(this.input)
193 }
194
195 decl(tokens, customProperty) {
196 let node = new Declaration()
197 this.init(node, tokens[0][2])
198
199 let last = tokens[tokens.length - 1]
200 if (last[0] === ';') {
201 this.semicolon = true
202 tokens.pop()
203 }
204
205 node.source.end = this.getPosition(
206 last[3] || last[2] || findLastWithPosition(tokens)
207 )
208 node.source.end.offset++
209
210 while (tokens[0][0] !== 'word') {
211 if (tokens.length === 1) this.unknownWord(tokens)
212 node.raws.before += tokens.shift()[1]
213 }
214 node.source.start = this.getPosition(tokens[0][2])
215
216 node.prop = ''
217 while (tokens.length) {
218 let type = tokens[0][0]
219 if (type === ':' || type === 'space' || type === 'comment') {
220 break
221 }
222 node.prop += tokens.shift()[1]
223 }
224
225 node.raws.between = ''
226
227 let token
228 while (tokens.length) {
229 token = tokens.shift()
230
231 if (token[0] === ':') {
232 node.raws.between += token[1]
233 break
234 } else {
235 if (token[0] === 'word' && /\w/.test(token[1])) {
236 this.unknownWord([token])
237 }
238 node.raws.between += token[1]
239 }
240 }
241
242 if (node.prop[0] === '_' || node.prop[0] === '*') {
243 node.raws.before += node.prop[0]
244 node.prop = node.prop.slice(1)
245 }
246
247 let firstSpaces = []
248 let next
249 while (tokens.length) {
250 next = tokens[0][0]
251 if (next !== 'space' && next !== 'comment') break
252 firstSpaces.push(tokens.shift())
253 }
254
255 this.precheckMissedSemicolon(tokens)
256
257 for (let i = tokens.length - 1; i >= 0; i--) {
258 token = tokens[i]
259 if (token[1].toLowerCase() === '!important') {
260 node.important = true
261 let string = this.stringFrom(tokens, i)
262 string = this.spacesFromEnd(tokens) + string
263 if (string !== ' !important') node.raws.important = string
264 break
265 } else if (token[1].toLowerCase() === 'important') {
266 let cache = tokens.slice(0)
267 let str = ''
268 for (let j = i; j > 0; j--) {
269 let type = cache[j][0]
270 if (str.trim().startsWith('!') && type !== 'space') {
271 break
272 }
273 str = cache.pop()[1] + str
274 }
275 if (str.trim().startsWith('!')) {
276 node.important = true
277 node.raws.important = str
278 tokens = cache
279 }
280 }
281
282 if (token[0] !== 'space' && token[0] !== 'comment') {
283 break
284 }
285 }
286
287 let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment')
288
289 if (hasWord) {
290 node.raws.between += firstSpaces.map(i => i[1]).join('')
291 firstSpaces = []
292 }
293 this.raw(node, 'value', firstSpaces.concat(tokens), customProperty)
294
295 if (node.value.includes(':') && !customProperty) {
296 this.checkMissedSemicolon(tokens)
297 }
298 }
299
300 doubleColon(token) {
301 throw this.input.error(
302 'Double colon',
303 { offset: token[2] },
304 { offset: token[2] + token[1].length }
305 )
306 }
307
308 emptyRule(token) {
309 let node = new Rule()
310 this.init(node, token[2])
311 node.selector = ''
312 node.raws.between = ''
313 this.current = node
314 }
315
316 end(token) {
317 if (this.current.nodes && this.current.nodes.length) {
318 this.current.raws.semicolon = this.semicolon
319 }
320 this.semicolon = false
321
322 this.current.raws.after = (this.current.raws.after || '') + this.spaces
323 this.spaces = ''
324
325 if (this.current.parent) {
326 this.current.source.end = this.getPosition(token[2])
327 this.current.source.end.offset++
328 this.current = this.current.parent
329 } else {
330 this.unexpectedClose(token)
331 }
332 }
333
334 endFile() {
335 if (this.current.parent) this.unclosedBlock()
336 if (this.current.nodes && this.current.nodes.length) {
337 this.current.raws.semicolon = this.semicolon
338 }
339 this.current.raws.after = (this.current.raws.after || '') + this.spaces
340 this.root.source.end = this.getPosition(this.tokenizer.position())
341 }
342
343 freeSemicolon(token) {
344 this.spaces += token[1]
345 if (this.current.nodes) {
346 let prev = this.current.nodes[this.current.nodes.length - 1]
347 if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
348 prev.raws.ownSemicolon = this.spaces
349 this.spaces = ''
350 prev.source.end = this.getPosition(token[2])
351 prev.source.end.offset += prev.raws.ownSemicolon.length
352 }
353 }
354 }
355
356 // Helpers
357
358 getPosition(offset) {
359 let pos = this.input.fromOffset(offset)
360 return {
361 column: pos.col,
362 line: pos.line,
363 offset
364 }
365 }
366
367 init(node, offset) {
368 this.current.push(node)
369 node.source = {
370 input: this.input,
371 start: this.getPosition(offset)
372 }
373 node.raws.before = this.spaces
374 this.spaces = ''
375 if (node.type !== 'comment') this.semicolon = false
376 }
377
378 other(start) {
379 let end = false
380 let type = null
381 let colon = false
382 let bracket = null
383 let brackets = []
384 let customProperty = start[1].startsWith('--')
385
386 let tokens = []
387 let token = start
388 while (token) {
389 type = token[0]
390 tokens.push(token)
391
392 if (type === '(' || type === '[') {
393 if (!bracket) bracket = token
394 brackets.push(type === '(' ? ')' : ']')
395 } else if (customProperty && colon && type === '{') {
396 if (!bracket) bracket = token
397 brackets.push('}')
398 } else if (brackets.length === 0) {
399 if (type === ';') {
400 if (colon) {
401 this.decl(tokens, customProperty)
402 return
403 } else {
404 break
405 }
406 } else if (type === '{') {
407 this.rule(tokens)
408 return
409 } else if (type === '}') {
410 this.tokenizer.back(tokens.pop())
411 end = true
412 break
413 } else if (type === ':') {
414 colon = true
415 }
416 } else if (type === brackets[brackets.length - 1]) {
417 brackets.pop()
418 if (brackets.length === 0) bracket = null
419 }
420
421 token = this.tokenizer.nextToken()
422 }
423
424 if (this.tokenizer.endOfFile()) end = true
425 if (brackets.length > 0) this.unclosedBracket(bracket)
426
427 if (end && colon) {
428 if (!customProperty) {
429 while (tokens.length) {
430 token = tokens[tokens.length - 1][0]
431 if (token !== 'space' && token !== 'comment') break
432 this.tokenizer.back(tokens.pop())
433 }
434 }
435 this.decl(tokens, customProperty)
436 } else {
437 this.unknownWord(tokens)
438 }
439 }
440
441 parse() {
442 let token
443 while (!this.tokenizer.endOfFile()) {
444 token = this.tokenizer.nextToken()
445
446 switch (token[0]) {
447 case 'space':
448 this.spaces += token[1]
449 break
450
451 case ';':
452 this.freeSemicolon(token)
453 break
454
455 case '}':
456 this.end(token)
457 break
458
459 case 'comment':
460 this.comment(token)
461 break
462
463 case 'at-word':
464 this.atrule(token)
465 break
466
467 case '{':
468 this.emptyRule(token)
469 break
470
471 default:
472 this.other(token)
473 break
474 }
475 }
476 this.endFile()
477 }
478
479 precheckMissedSemicolon(/* tokens */) {
480 // Hook for Safe Parser
481 }
482
483 raw(node, prop, tokens, customProperty) {
484 let token, type
485 let length = tokens.length
486 let value = ''
487 let clean = true
488 let next, prev
489
490 for (let i = 0; i < length; i += 1) {
491 token = tokens[i]
492 type = token[0]
493 if (type === 'space' && i === length - 1 && !customProperty) {
494 clean = false
495 } else if (type === 'comment') {
496 prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty'
497 next = tokens[i + 1] ? tokens[i + 1][0] : 'empty'
498 if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
499 if (value.slice(-1) === ',') {
500 clean = false
501 } else {
502 value += token[1]
503 }
504 } else {
505 clean = false
506 }
507 } else {
508 value += token[1]
509 }
510 }
511 if (!clean) {
512 let raw = tokens.reduce((all, i) => all + i[1], '')
513 node.raws[prop] = { raw, value }
514 }
515 node[prop] = value
516 }
517
518 rule(tokens) {
519 tokens.pop()
520
521 let node = new Rule()
522 this.init(node, tokens[0][2])
523
524 node.raws.between = this.spacesAndCommentsFromEnd(tokens)
525 this.raw(node, 'selector', tokens)
526 this.current = node
527 }
528
529 spacesAndCommentsFromEnd(tokens) {
530 let lastTokenType
531 let spaces = ''
532 while (tokens.length) {
533 lastTokenType = tokens[tokens.length - 1][0]
534 if (lastTokenType !== 'space' && lastTokenType !== 'comment') break
535 spaces = tokens.pop()[1] + spaces
536 }
537 return spaces
538 }
539
540 // Errors
541
542 spacesAndCommentsFromStart(tokens) {
543 let next
544 let spaces = ''
545 while (tokens.length) {
546 next = tokens[0][0]
547 if (next !== 'space' && next !== 'comment') break
548 spaces += tokens.shift()[1]
549 }
550 return spaces
551 }
552
553 spacesFromEnd(tokens) {
554 let lastTokenType
555 let spaces = ''
556 while (tokens.length) {
557 lastTokenType = tokens[tokens.length - 1][0]
558 if (lastTokenType !== 'space') break
559 spaces = tokens.pop()[1] + spaces
560 }
561 return spaces
562 }
563
564 stringFrom(tokens, from) {
565 let result = ''
566 for (let i = from; i < tokens.length; i++) {
567 result += tokens[i][1]
568 }
569 tokens.splice(from, tokens.length - from)
570 return result
571 }
572
573 unclosedBlock() {
574 let pos = this.current.source.start
575 throw this.input.error('Unclosed block', pos.line, pos.column)
576 }
577
578 unclosedBracket(bracket) {
579 throw this.input.error(
580 'Unclosed bracket',
581 { offset: bracket[2] },
582 { offset: bracket[2] + 1 }
583 )
584 }
585
586 unexpectedClose(token) {
587 throw this.input.error(
588 'Unexpected }',
589 { offset: token[2] },
590 { offset: token[2] + 1 }
591 )
592 }
593
594 unknownWord(tokens) {
595 throw this.input.error(
596 'Unknown word ' + tokens[0][1],
597 { offset: tokens[0][2] },
598 { offset: tokens[0][2] + tokens[0][1].length }
599 )
600 }
601
602 unnamedAtrule(node, token) {
603 throw this.input.error(
604 'At-rule without name',
605 { offset: token[2] },
606 { offset: token[2] + token[1].length }
607 )
608 }
609}
610
611module.exports = Parser
Note: See TracBrowser for help on using the repository browser.