How to use the rtlcss.process function in rtlcss

.then( result => {
							// save the file
							saveFile( outFile, result.css );
							// save the RTL version file
							if ( withRTL ) {
								saveFile( outFile.replace( '.css', '-rtl.css' ), rtlcss.process( result.css ) );
							}

							resolve( outFile );
						} );
				}

chunk.files.forEach(asset => {
          const match = this.options.test ? new RegExp(this.options.test).test(asset) : true

          if (path.extname(asset) !== '.css') {
            return
          }

          const baseSource = compilation.assets[asset].source()
          let filename
          let rtlSource

          if (match) {
            rtlSource = rtlcss.process(baseSource, this.options.options, this.options.plugins)

            if (this.options.filename instanceof Array && this.options.filename.length === 2) {
              filename = asset.replace(this.options.filename[0], this.options.filename[1])
            }
            else if (this.options.filename) {
              filename = this.options.filename

              if (/\[contenthash]/.test(this.options.filename)) {
                const hash = createHash('md5').update(rtlSource).digest('hex').substr(0, 10)
                filename = filename.replace('[contenthash]', hash)
              }
              if (/\[id]/.test(this.options.filename)) {
                filename = filename.replace('[id]', chunk.id)
              }
              if (/\[name]/.test(this.options.filename)) {
                filename = filename.replace('[name]', chunk.name)

const rtlifyDecl = (decl, keyframes) => {
  let {prop, value} = decl;

  if (decl.prop.match(/animation/)) {
    value = getProcessedKeyframeValue(decl, keyframes, 'rtl');
  } else {
    const rtlResult = rtlcss.process(decl, null, null);

    if (rtlResult === decl.toString()) {
      return null;
    }

    [, prop, value] = rtlResult.match(/([^:]*):\s*(.*)/) || [];

    value = value.replace(/\s*!important/, '');
  }
  return {prop, value};
};

const rtlifyRule = (rule) => {
  const rtlResult = rtlcss.process(rule, null, null);

  return (rtlResult !== rule.toString()) ? rtlResult : false;
};

const addCss = styles => (
		css.push( isRtl ? rtlcss.process( styles._getCss() ) : styles._getCss() )
	);

}

    if (options.includeBaseFile || typeof options.includeBaseFile === "undefined") {
      if (langResult) {
        langCSS = result.css + "\n" + langResult + "\n";
      } else {
        langCSS = result.css;
      }
    } else if (langResult) {
      langCSS = langResult + "\n";
    }

    if (options.rtlLangs && options.rtlLangs.indexOf(lang) >= 0) {
      addOutputFile(
        rtlcss.process(langCSS, options.rtlOptions),
        langFilename
      );
    } else {
      addOutputFile(langCSS, langFilename);
    }
  });
};

return through.obj(function (file, enc, cb) {
        if (file.isNull()) {
            return cb(null, file);
        }

        if (file.isStream()) {
            return cb(new gutil.PluginError('apex-frontend-boost-rtlcss', 'Streaming not supported'));
        }

        if (file.extname == '.map') {
            return cb(null, file);
        }

        file.contents = new Buffer(rtlcss.process(file.contents.toString()));
        this.push(file);
        cb();
    });
};

this.cache.parseLess = (filePath, contents) => {
        const { imports, css } = original.call(this.cache, filePath, contents);
        return { imports, css: rtlcss.process(css) };
      };
    }

module.exports.default = function(str) {
  str = ".ldc-ltr {" + str + "} .ldc-rtl {" + rtlcss.process(str) + "}"
  return str
}

this.cache.parseLess = (filePath, contents) => {
        const { imports, css } = original.call(this.cache, filePath, contents);
        return { imports, css: rtlcss.process(css) };
      };
    }