How to use the parse5.Parser function in parse5

var fs = require('fs')
var parse5 = require('parse5');
var parser = new parse5.Parser();

var filename = process.argv[2];
if (!filename){
    console.log('You must supply a filename');
    process.exit();
}
var origHtml = fs.readFileSync(filename, {encoding: 'utf-8'});
var document = parser.parseFragment(origHtml);

// Do the refactoring here
function walk(node, fn){
    fn(node);
    if (!node['childNodes']) return;
    node.childNodes.forEach(function(child){
        walk(child,fn);
    });

var _marked = require('marked');

var _marked2 = _interopRequireDefault(_marked);

var _highlightJs = require('highlight.js');

var _highlightJs2 = _interopRequireDefault(_highlightJs);

var _parse5 = require('parse5');

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var parser = new _parse5.Parser();

var Renderer = (function (_marked$Renderer) {
	_inherits(Renderer, _marked$Renderer);

	function Renderer() {
		_classCallCheck(this, Renderer);

		_get(Object.getPrototypeOf(Renderer.prototype), 'constructor', this).apply(this, arguments);
	}

	_createClass(Renderer, [{
		key: 'heading',

		// Do not put IDs in headers
		value: function heading(text, level) {
			var tag = 'h' + level;

clone(node) {
    // e.g. document fragment
    if (node.type === 'root') {
      var serialized = serializer.serialize(node);
      var newParser = new parse5.Parser(parse5.TreeAdapters.htmlparser2);
      return newParser.parseFragment(serialized);
    } else {
      var temp = treeAdapter.createElement("template", null, []);
      treeAdapter.appendChild(temp, node);
      var serialized = serializer.serialize(temp);
      var newParser = new parse5.Parser(parse5.TreeAdapters.htmlparser2);
      return newParser.parseFragment(serialized).childNodes[0];
    }
  }
  getElementsByClassName(element, name: string) {

import {Parser, Serializer, TreeAdapters} from 'parse5';
import {getDOM} from '@angular/platform-browser/src/dom/dom_adapter';


const parser = new Parser(TreeAdapters.htmlparser2);
// TODO(gdi2290): fix encodeHtmlEntities: true
const serializer = new Serializer(TreeAdapters.htmlparser2, { encodeHtmlEntities: true });
const treeAdapter = parser.treeAdapter;

export function isTag (tagName, node): boolean {
  return node.type === 'tag' && node.name === tagName;
}

export function parseFragment (el: string): any {
  return parser.parseFragment(el);
}

export function parseDocument (documentHtml: string): any {
  if (documentHtml === undefined) {
    throw new Error('parseDocument requires a document string');
  }

export default function format (err, decorator, viewportWidth) {
    var parser   = new Parser();
    var fragment = parser.parseFragment(TEMPLATES[err.type](err, viewportWidth));

    return decorateHTML(fragment, decorator);
}

var Benchmark = require('benchmark'),
    upstream = require('parse5'),
    workingCopy = require('../index'),
    path = require('path'),
    fs = require('fs');

var testHtml = fs.readFileSync(path.join(__dirname, './spec.html')).toString(),
    wcParser = new workingCopy.Parser(),
    usParser = new upstream.Parser();

new Benchmark.Suite()
    .add('Working copy', function () {
        wcParser.parse(testHtml);
    })

    .add('Upstream', function () {
        usParser.parse(testHtml);
    })

    .on('start', function () {
        console.log('Benchmarking...')
    })

    .on('cycle', function (event) {
        console.log(event.target.toString());

function parseFragment(text) {
  var parser = new parse5.Parser();
  return parser.parseFragment(text);
}

parse(html) {
    var parser = new parse5.Parser()
    var fragment = parser.parseFragment(html)
    return fragment
  }

constructor() {
    super();
    this.state = { parser: new Parser() };
  }