postcss 8.5.13 → 8.5.15

package/lib/parser.js

@@ -20,6 +20,12 @@ function findLastWithPosition(tokens) {
   }
 }
 
+function tokensToString(tokens, from, to) {
+  let result = ''
+  for (let i = from; i < to; i++) result += tokens[i][1]
+  return result
+}
+
 class Parser {
   constructor(input) {
     this.input = input
@@ -132,9 +138,10 @@ class Parser {
         if (founded === 2) break
       }
     }
-    // If the token is a word, e.g. `!important`, `red` or any other valid property's value.
-    // Then we need to return the colon after that word token. [3] is the "end" colon of that word.
-    // And because we need it after that one we do +1 to get the next one.
+    // If the token is a word, e.g. `!important`, `red` or any other valid
+    // property's value. Then we need to return the colon after that word
+    // token. [3] is the "end" colon of that word. And because we need it
+    // after that one we do +1 to get the next one.
     throw this.input.error(
       'Missed semicolon',
       token[0] === 'word' ? token[3] + 1 : token[2]
@@ -207,50 +214,50 @@ class Parser {
     )
     node.source.end.offset++
 
-    while (tokens[0][0] !== 'word') {
-      if (tokens.length === 1) this.unknownWord(tokens)
-      node.raws.before += tokens.shift()[1]
+    let start = 0
+    while (tokens[start][0] !== 'word') {
+      if (start === tokens.length - 1) this.unknownWord([tokens[start]])
+      start++
     }
-    node.source.start = this.getPosition(tokens[0][2])
+    node.raws.before += tokensToString(tokens, 0, start)
+    node.source.start = this.getPosition(tokens[start][2])
 
-    node.prop = ''
-    while (tokens.length) {
-      let type = tokens[0][0]
+    let propStart = start
+    while (start < tokens.length) {
+      let type = tokens[start][0]
       if (type === ':' || type === 'space' || type === 'comment') {
         break
       }
-      node.prop += tokens.shift()[1]
+      start++
     }
+    node.prop = tokensToString(tokens, propStart, start)
 
-    node.raws.between = ''
-
+    let betweenStart = start
     let token
-    while (tokens.length) {
-      token = tokens.shift()
-
-      if (token[0] === ':') {
-        node.raws.between += token[1]
-        break
-      } else {
-        if (token[0] === 'word' && /\w/.test(token[1])) {
-          this.unknownWord([token])
-        }
-        node.raws.between += token[1]
+    while (start < tokens.length) {
+      token = tokens[start]
+      start++
+      if (token[0] === ':') break
+      if (token[0] === 'word' && /\w/.test(token[1])) {
+        this.unknownWord([token])
       }
     }
+    node.raws.between = tokensToString(tokens, betweenStart, start)
 
     if (node.prop[0] === '_' || node.prop[0] === '*') {
       node.raws.before += node.prop[0]
       node.prop = node.prop.slice(1)
     }
 
-    let firstSpaces = []
-    let next
-    while (tokens.length) {
-      next = tokens[0][0]
+    let firstSpacesStart = start
+    while (start < tokens.length) {
+      let next = tokens[start][0]
       if (next !== 'space' && next !== 'comment') break
-      firstSpaces.push(tokens.shift())
+      start++
     }
+    let firstSpaces = tokens.slice(firstSpacesStart, start)
+
+    tokens = tokens.slice(start)
 
     this.precheckMissedSemicolon(tokens)
 

package/lib/processor.js

@@ -7,7 +7,7 @@ let Root = require('./root')
 
 class Processor {
   constructor(plugins = []) {
-    this.version = '8.5.13'
+    this.version = '8.5.15'
     this.plugins = this.normalize(plugins)
   }
 

package/lib/stringifier.js

@@ -85,23 +85,15 @@ class Stringifier {
   }
 
   block(node, start) {
-    let raws = node.raws
-    let between =
-      typeof raws.between !== 'undefined'
-        ? raws.between
-        : this.raw(node, 'between', 'beforeOpen')
+    let between = this.raw(node, 'between', 'beforeOpen')
     this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start')
 
     let after
     if (node.nodes && node.nodes.length) {
       this.body(node)
-      after =
-        typeof raws.after !== 'undefined' ? raws.after : this.raw(node, 'after')
+      after = this.raw(node, 'after')
     } else {
-      after =
-        typeof raws.after !== 'undefined'
-          ? raws.after
-          : this.raw(node, 'after', 'emptyBody')
+      after = this.raw(node, 'after', 'emptyBody')
     }
 
     if (after) this.builder(escapeHTMLInCSS(after))
@@ -120,34 +112,21 @@ class Stringifier {
     let isDocument = node.type === 'document'
     for (let i = 0; i < nodes.length; i++) {
       let child = nodes[i]
-      let before = child.raws.before
-      if (typeof before === 'undefined') {
-        before = this.raw(child, 'before')
-      }
+      let before = this.raw(child, 'before')
       if (before) this.builder(isDocument ? before : escapeHTMLInCSS(before))
       this.stringify(child, last !== i || semicolon)
     }
   }
 
   comment(node) {
-    let raws = node.raws
-    let left =
-      typeof raws.left !== 'undefined'
-        ? raws.left
-        : this.raw(node, 'left', 'commentLeft')
-    let right =
-      typeof raws.right !== 'undefined'
-        ? raws.right
-        : this.raw(node, 'right', 'commentRight')
+    let left = this.raw(node, 'left', 'commentLeft')
+    let right = this.raw(node, 'right', 'commentRight')
     this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node)
   }
 
   decl(node, semicolon) {
     let raws = node.raws
-    let between =
-      typeof raws.between !== 'undefined'
-        ? raws.between
-        : this.raw(node, 'between', 'colon')
+    let between = this.raw(node, 'between', 'colon')
 
     let string = node.prop + between + this.rawValue(node, 'value')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "postcss",
-  "version": "8.5.13",
+  "version": "8.5.15",
   "description": "Tool for transforming styles with JS plugins",
   "keywords": [
     "css",
@@ -78,7 +78,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "nanoid": "^3.3.11",
+    "nanoid": "^3.3.12",
     "picocolors": "^1.1.1",
     "source-map-js": "^1.2.1"
   },