How to use the postcss.root function in postcss

function generateDataFile (css, opts) {
	var dataCSS = postcss.root();

	dataCSS.append(css);
	getData(dataCSS, opts);

	if (typeof opts.dest === 'string') {
		opts.dest = {
			path: opts.dest
		};
	};

	var dataOpts = {
		to: (typeof opts.dest.path === 'function') ? opts.dest.path(opts) : opts.dest.path
	};

	// если нет информации о карте кода
	if (!opts.dest.map) {

export function createClassSubsetRoot(root: postcss.Root, selectorPrefix: string) {
    const mixinRoot = postcss.root();
    let addRootDecls = true;
    root.nodes!.forEach((node: SRule) => {
        if (node.type === 'rule') {
            if (node.selector.startsWith(selectorPrefix) && node.selector.indexOf(',') === -1) {
                if (addRootDecls && node.selectorType === 'class') {
                    addRootDecls = false;
                    node.walkDecls(decl => {
                        mixinRoot.append(decl.clone());
                    });
                } else {
                    // TODO: handle complex selectors with ,
                    const clone: SRule = node.clone({
                        selector: node.selector.replace(selectorPrefix, '&')
                    });
                    // TODO: maybe delete clone.selectorAst
                    mixinRoot.append(clone);

const collect = (html: string, css: string): CollectResult => {
  const animations = new Set();
  const other = postcss.root();
  const critical = postcss.root();
  const stylesheet = postcss.parse(css);
  const htmlClassesRegExp = extractClassesFromHtml(html);

  const isCritical = rule => {
    // Only check class names selectors
    if (rule.selector.startsWith('.')) {
      return Boolean(rule.selector.match(htmlClassesRegExp));
    }

    return true;
  };

  const handleAtRule = rule => {
    let addedToCritical = false;

beforeEach(() => {
    root = postcss.root();
    componentRoot = postcss.rule({selector: '.Component'});
    root.append(componentRoot);
  });

var meta = mixins[name]
  var mixin = meta && meta.mixin

  if (!meta) {
    if (!opts.silent) {
      throw rule.error('Undefined mixin ' + name)
    }
  } else if (mixin.name === 'define-mixin') {
    var i
    var values = { }
    for (i = 0; i < meta.args.length; i++) {
      values[meta.args[i][0]] = params[i] || meta.args[i][1]
    }

    var proxy = postcss.root()
    for (i = 0; i < mixin.nodes.length; i++) {
      var node = mixin.nodes[i].clone()
      delete node.raws.before
      proxy.append(node)
    }

    if (meta.args.length) {
      vars({ only: values })(proxy)
    }

    if (meta.content) processMixinContent(proxy, rule)
    processMixins(proxy)

    rule.parent.insertBefore(rule, proxy)
  } else if (typeof mixin === 'object') {
    insertObject(rule, mixin, processMixins)

cssVarsMapping
            )
        );
        if (
            (resolvedClass.symbol._kind === 'class' || resolvedClass.symbol._kind === 'element') &&
            !resolvedClass.symbol[valueMapping.extends]
        ) {
            resolvedClass = transformer.resolver.resolve(resolvedClass.symbol) as CSSResolve;
        } else {
            break;
        }
    }
    if (roots.length === 1) {
        mergeRules(roots[0], rule);
    } else if (roots.length > 1) {
        const mixinRoot = postcss.root();
        roots.forEach(root => mixinRoot.prepend(...root.nodes!));
        mergeRules(mixinRoot, rule);
    } else {
        const mixinDecl = getMixinDeclaration(rule);

        if (mixinDecl) {
            transformer.diagnostics.error(
                mixinDecl,
                mixinWarnings.UNKNOWN_MIXIN_SYMBOL(mixinDecl.value),
                { word: mixinDecl.value }
            );
        }
    }
}

parse (node) {
		const root = postcss.root({
			source: {
				input: this.input,
				start: node.loc.start,
			},
		});
		root.raws.node = node;
		const obj = new ObjectLiteral({
			raws: {
				node,
			},
		});
		root.push(obj);
		this.process(node, obj);
		this.sort(root);
		this.raws(root);

function hasNoOtherChildNodes(
  nodes: Array = [],
  node: Object = postcss.root()
): boolean {
  return nodes.filter((child: Object): boolean => child !== node).length === 0;
}

parseTree: postcss
            .root()
            .append(
              cssAsset.parseTree.nodes.slice(offset, i).map(Css.cloneWithRaws)
            )
        });

        offset = i;
        accumulatedRules = selectors;
      }
    }

    output.push({
      type: cssAsset.type,
      isPopulated: false,
      parseTree: postcss
        .root()
        .append(cssAsset.parseTree.nodes.slice(offset).map(Css.cloneWithRaws))
    });

    return output;
  }

const parse = contents => {
	const obj = xml(contents);
	const root = postcss.root();

	traverseTree(obj.root.children).forEach(_ => root.append(_));

	return root;
};