code: function () {
                  var mixin = this.mixin, root = [], node;
  
                  while (true) {
                      while (true) {
                          node = this.comment();
                          if (!node) { break; }
                          root.push(node);
                      }
                      // always process comments before deciding if finished
                      if (parserInput.finished) {
                          break;
                      }
                      if (parserInput.peek('}')) {
                          break;
                      }
  
                      node = this.extendRule();
                      if (node) {
                          root = root.concat(node);
                          continue;
                      }
  
                      node = mixin.definition() || this.declaration() || this.ruleset() ||
                          mixin.call(false, false) || this.variableCall() || this.entities.call() || this.atrule();
                      if (node) {
                          root.push(node);
                      } else {
                          var foundSemiColon = false;
                          while (parserInput.$char(';')) {
                              foundSemiColon = true;
                          }
                          if (!foundSemiColon) {
                              break;
                          }
                      }
                  }
  
                  return root;
              }
docs: The `primary` rule is the *entry* and *exit* point of the parser. The rules here can appear at any level of the parse tree.  The recursive nature of the grammar is an interplay between the `block` rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule, as represented by this simplified grammar:  primary  →  (ruleset | declaration)+ ruleset  →  selector+ block block    →  '{' primary '}'  Only at one point is the primary rule not called from the block rule: at the root level.