Use PostCSS 7

lib/less-parser.js

@@ -1,6 +1,8 @@
 import Comment from 'postcss/lib/comment';
+import Declaration from 'postcss/lib/declaration';
 import Import from './import';
 import Parser from 'postcss/lib/parser';
+import AtRule from 'postcss/lib/at-rule';
 import Rule from './rule';
 import Root from './root';
 import findExtendRule from './find-extend-rule';
@@ -13,6 +15,7 @@ export default class LessParser extends Parser {
 
   constructor (input) {
     super(input);
+    this.pos = 0;
 
     this.root = new Root();
     this.current = this.root;
@@ -24,7 +27,7 @@ export default class LessParser extends Parser {
       this.import(token);
     }
     else {
-      super.atrule(token);
+      this.originAtrule(token);
     }
   }
 
@@ -410,5 +413,201 @@ export default class LessParser extends Parser {
     this.tokens = lessTokenizer(this.input);
   }
 
+  unknownWord (start) {
+    let token = this.tokens[start];
+    throw this.input.error('Unknown word', token[2], token[3]);
+  }
+
+  emptyRule (token) {
+    let node = new Rule();
+    this.init(node, token[2], token[3]);
+    node.selector = '';
+    node.raws.between = '';
+    this.current = node;
+  }
+
+  loop () {
+    let token;
+    while ( this.pos < this.tokens.length ) {
+      token = this.tokens[this.pos];
+
+      switch ( token[0] ) {
+
+        case 'space':
+        case ';':
+          this.spaces += token[1];
+          break;
+
+        case '}':
+          this.end(token);
+          break;
+
+        case 'comment':
+          this.comment(token);
+          break;
+
+        case 'at-word':
+          this.atrule(token);
+          break;
+
+        case '{':
+          this.emptyRule(token);
+          break;
+
+        default:
+          this.other();
+          break;
+      }
+
+      this.pos += 1;
+    }
+    this.endFile();
+  }
+
+  originAtrule (token) {
+    let node = new AtRule(), last = false, open = false, params = [];
+    node.name = token[1].slice(1);
+    if ( node.name === '' ) {
+      this.unnamedAtrule(node, token);
+    }
+    this.init(node, token[2], token[3]);
+
+    this.pos += 1;
+    while ( this.pos < this.tokens.length ) {
+      token = this.tokens[this.pos];
+
+      if ( token[0] === ';' ) {
+        node.source.end = { line: token[2], column: token[3] };
+        this.semicolon = true;
+        break;
+      }
+      else if ( token[0] === '{' ) {
+        open = true;
+        break;
+      }
+      else if ( token[0] === '}') {
+        this.end(token);
+        break;
+      }
+      else {
+        params.push(token);
+      }
+
+      this.pos += 1;
+    }
+    if ( this.pos === this.tokens.length ) {
+      last = true;
+    }
+
+    node.raws.between = this.spacesAndCommentsFromEnd(params);
+    if ( params.length ) {
+      node.raws.afterName = this.spacesAndCommentsFromStart(params);
+      this.raw(node, 'params', params);
+      if ( last ) {
+        token = params[params.length - 1];
+        node.source.end   = { line: token[4], column: token[5] };
+        this.spaces       = node.raws.between;
+        node.raws.between = '';
+      }
+    }
+    else {
+      node.raws.afterName = '';
+      node.params         = '';
+    }
+
+    if ( open ) {
+      node.nodes   = [];
+      this.current = node;
+    }
+  }
+
+  decl (tokens) {
+    let node, last, token;
+    node = new Declaration();
+    this.init(node);
+
+    last = tokens[tokens.length - 1];
+    if ( last[0] === ';' ) {
+      this.semicolon = true;
+      tokens.pop();
+    }
+    if ( last[4] ) {
+      node.source.end = { line: last[4], column: last[5] };
+    }
+    else {
+      node.source.end = { line: last[2], column: last[3] };
+    }
+
+    while ( tokens[0][0] !== 'word' ) {
+      node.raws.before += tokens.shift()[1];
+    }
+    node.source.start = { line: tokens[0][2], column: tokens[0][3] };
+
+    node.prop = '';
+    while ( tokens.length ) {
+      let type = tokens[0][0];
+      if ( type === ':' || type === 'space' || type === 'comment' ) {
+        break;
+      }
+      node.prop += tokens.shift()[1];
+    }
+
+    node.raws.between = '';
+
+    while ( tokens.length ) {
+      token = tokens.shift();
+
+      if ( token[0] === ':' ) {
+        node.raws.between += token[1];
+        break;
+      }
+      else {
+        node.raws.between += token[1];
+      }
+    }
+
+    if ( node.prop[0] === '_' || node.prop[0] === '*' ) {
+      node.raws.before += node.prop[0];
+      node.prop = node.prop.slice(1);
+    }
+    node.raws.between += this.spacesAndCommentsFromStart(tokens);
+    this.precheckMissedSemicolon(tokens);
+
+    for ( let i = tokens.length - 1; i > 0; i-- ) {
+      token = tokens[i];
+      if ( token[1] === '!important' ) {
+        node.important = true;
+        let string = this.stringFrom(tokens, i);
+        string = this.spacesFromEnd(tokens) + string;
+        if ( string !== ' !important' ) node.raws.important = string;
+        break;
+
+      }
+      else if (token[1] === 'important') {
+        let cache = tokens.slice(0), str = '';
+        for ( let j = i; j > 0; j-- ) {
+          let type = cache[j][0];
+          if ( str.trim().indexOf('!') === 0 && type !== 'space' ) {
+            break;
+          }
+          str = cache.pop()[1] + str;
+        }
+        if ( str.trim().indexOf('!') === 0 ) {
+          node.important = true;
+          node.raws.important = str;
+          tokens = cache;
+        }
+      }
+
+      if ( token[0] !== 'space' && token[0] !== 'comment' ) {
+        break;
+      }
+    }
+
+    this.raw(node, 'value', tokens);
+
+    if ( node.value.indexOf(':') !== -1 ) this.checkMissedSemicolon(tokens);
+  }
+
     /* eslint-enable max-statements, complexity */
 }