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.
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;
            }