docs: function(){
                  /*
                   * ruleset
                   *   : selectors_group
                   *     '{' S* declaration? [ ';' S* declaration? ]* '}' S*
                   *   ;
                   */
  
                  var tokenStream = this._tokenStream,
                      tt,
                      selectors;
  
                  var node = this.startNode('Rule', tokenStream.curr().range[0], 'body'); //ORION AST generation
                  /*
                   * Error Recovery: If even a single selector fails to parse,
                   * then the entire ruleset should be thrown away.
                   */
                  try {
                      selectors = this._selectors_group();
                  } catch (ex){
                      if (ex instanceof SyntaxError && !this.options.strict){
  
                          //fire error event
                          this.fire({
                              type:       "error",
                              error:      ex,
                              message:    ex.message,
                              line:       ex.line,
                              col:        ex.col
                          });
  
                          //skip over everything until closing brace
                          tt = tokenStream.advance([Tokens.RBRACE]);
                          if (tt === Tokens.RBRACE){
                              //if there's a right brace, the rule is finished so don't do anything
                          } else {
                              //otherwise, rethrow the error because it wasn't handled properly
                              throw ex;
                          }
  
                      } else {
                          //not a syntax error, rethrow it
                          throw ex;
                      }
  
                      //trigger parser to continue
                      return true;
                  }
  
                  //if it got here, all selectors parsed
                  if (selectors){
  
                      this.fire({
                          type:       "startrule",
                          selectors:  selectors,
                          line:       selectors[0].line,
                          col:        selectors[0].col
                      });
  
                      this._readDeclarations(true);
                      
                      this.fire({
                          type:       "endrule",
                          selectors:  selectors,
                          line:       selectors[0].line,
                          col:        selectors[0].col
                      });
                      
                      var rbraceRange = this.findLastTokenRange('RBRACE', node.range[0]); // ORION AST Generation select the RBRACE token
                      this.endNode(node, rbraceRange[1]); //ORION AST Generation
                  }
  
  				// ORION AST Generation, don't create an empty rule node if no rule selectors found
                  if (selectors === null){
                      this.removeNode(node, 'body');
                  }
                  return selectors;
  
              }