How to use the gonzales-pe.parse function in gonzales-pe

it('Should lint, multiple errors', function() {
        var comb = new Comb();
        var ast = originalAST = gonzales.parse('a{color:red}');
        var error = {line:1, column: 7, message: 'foo'};
        comb.plugins = [{
            syntax: ['css'],
            lint: function(node) {
                return [error, error];
            }
        }];
        assert.deepEqual([error, error], comb.lintTree(ast, 'css'));
        // Should not modify ast:
        assert.deepEqual(originalAST, ast);
    });
});

module.exports = function (text, syntax, filename) {
  var tree;

  // Run `.toString()` to allow Buffers to be passed in
  text = helpers.stripBom(text.toString());

  // if we're skipping front matter do it here, fall back to just our text in case it fails
  if (fm.test(text)) {
    text = fm(text).body || text;
  }

  try {
    tree = gonzales.parse(text, {
      'syntax': syntax
    });
  }
  catch (e) {
    throw {
      message: e.message,
      file: filename,
      line: e.line
    };
  }

  if (typeof tree === 'undefined') {
    throw {
      message: 'Undefined tree',
      file: filename,
      text: text.toString(),

loadSource: function(source) {
    if (typeof source === 'object') {
      this.ast = source;
    }
    else if (typeof source === 'string') {
      // JSON source:
      if (isJSON(source)) {
        this.ast = JSON.parse(source);
      }
      // Sass source:
      else {
        this.ast = gonzales.parse(source, {syntax: 'scss'});
      }
    }
    else {
      throw 'Source could not be loaded.';
    }

    return this.resetMapping();
  },

function symdiffSASS(sassString) {
    var ast;
    try {
        // try SCSS first
        ast = gonzales.parse(sassString, {
            syntax: 'scss'
        });
    } catch(err1) {
        try {
            // try SASS second
            ast = gonzales.parse(sassString, {
                syntax: 'sass'
            });
        } catch(err2) {
            // ok whatever
            return [];
        }
    }

    var classes = [];
    walk(ast, function(node) {

var fs = require('fs');
var gonzales = require('gonzales-pe');

var css = fs.readFileSync(__dirname + '/file.css', 'utf-8');
var ast = gonzales.parse(css);

module.exports = ast;

const {
			bm,
			be,
			componentName,
			component: DemoComponent,
			stylesheet,
			propExamples,
			maxExamplesCount,
		} = this.props;

		const modifierGroups = {};
		let configurations;

		let stylesheetAst;
		if (stylesheet) {
			stylesheetAst = gonzales.parse(stylesheet, { syntax: 'css' });
			extractModifiers(stylesheetAst, modifierGroups);
			console.log(modifierGroups);
		}

		const fullConfigsCount = countConfigs(modifierGroups);
		const fullExamplesCountLimitExceeded = fullConfigsCount > maxExamplesCount;
		if (!maxExamplesCount || fullExamplesCountLimitExceeded) {
			configurations = generateSimpleConfigs(modifierGroups);
		} else {
			configurations = generateConfigs(modifierGroups);
		}

		return (
			<div>

				<div></div></div>

fn: function () {
                gonzalesPe.parse(css).toString();
            }
        },

return new Promise(function(resolve) {
      try {
        tree = gonzales.parse(text, {syntax: syntax, rule: context});
        resolve(tree, filename);
      } catch (e) {
        let version = require('../package.json').version;
        let message = filename ? [filename] : [];
        message.push(e.message);
        message.push('CSScomb Core version: ' + version);
        e.stack = e.message = message.join(os.EOL);
        throw e;
      }
    });
  }

tokenFiles.less.forEach(tokenFile => {
      const parsed = gonzales.parse(tokenFile.content, { syntax: 'less' });

      parsed.traverseByType('block', block => {
        block.forEach('declaration', declaration => {
          const value = declaration.first('value');

          if (!value.is('variable')) {
            hardCodedValues.push({
              file: tokenFile.filename,
              line: value.start.line,
              value: this.mapPropertyValue(value)
            });
          }
        });
      });
    });

static getRulesetFromSelectorsString(content) {
    return gonzales.parse(`${content} {}`)
  }
}