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;
            }
function () {
                var mixin = this.mixin, root = [], node;

                while (true) {
                    while (true) {
                        node = this.comment();
                        if (!node) { break; }
                        root.push(node);
                    }
                    
                    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;
            }
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 ; }
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.
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 .