How to use the remark function in remark

function description(text, opts = {}) {
  opts = { ...defaultOpts, ...opts }

  if (opts.pruneLength === 0) {
    console.warn(
      "You defined 'description.pruneLength' of phenomic loader " +
      "with an zero value. This does not make sense, " +
      `so the default value ${ defaultOpts.pruneLength } has been used.`
    )

    opts.pruneLength = defaultOpts.pruneLength
  }

  return prune(
    remark()
      .use(stripMd)
      .process(text)
      .toString()
      .replace(/\n+/g, " ") // Avoid useless new lines
      .trim()
    ,
    opts.pruneLength,
    opts.pruneString
  )
}

// @flow
import fs from 'fs'
import remark from 'remark'
import html from 'remark-html'
import hljs from 'remark-highlight.js'
import slug from 'remark-slug'
import headding from 'remark-autolink-headings'

const app = remark()
app.use([slug, headding, html])

export default (file: string): string => {
  let markdown: string = fs.readFileSync(file).toString('utf8')
  const { contents } = app.processSync(markdown)

  return contents
}

render() {
    return remark()
      .use(remarkReactRenderer, {
        sanitize: sanitization,
        remarkReactComponents: {
          a: ({href, children}) => {
            if (href.match(/^https?:\/\//i) || href.startsWith('mailto:')) {
              // External Link
              return <a href="{href}">{children}</a>;
            }
            return {children};
          },
          code: ({className, children}) =&gt; {
            let language;
            if (className &amp;&amp; className.startsWith('language-')) {
              language = className.slice('language-'.length);
            }
            return <code>{children[0]}</code>;

function renderHighlighted(nodes) {
  return {
    __html: postHighlight(remark()
      .use(remarkHTML)
      .stringify(remark()
        .use(remarkHighlight)
        .use(remarkPlugins)
        .runSync({
          type: 'root',
          children: nodes
        })))
  };
}

import remark from "remark";
import github from "remark-github";
import markdown from "remark-parse";
import html from "remark-html";

const pipeline = remark()
  .use(github)
  .use(markdown)
  .use(html);

export default (markdown: string): string =>
  pipeline.processSync(markdown).contents;

export default function (rootPath, context, demoTemplate) {
  demoTemplate = demoTemplate || '';

  var readme = fs.readFileSync(
    path.join(rootPath, 'README.md'), 'utf8'
  );

  return {
    name: context.name,
    description: context.description,
    demonstration: demoTemplate,
    documentation: ReactDOM.renderToStaticMarkup(
      <div>
        {remark().use(reactRenderer, {
          remarkReactComponents: {
            code: RemarkLowlight({
              js
            })
          }
        }).process(readme)}
      </div>
    )
  };
}

export function markdownToReact(markdown, remarkReactComponents = {}) {
    return remark()
        .use(remark2react, { remarkReactComponents })
        .processSync(markdown).contents
}

function renderHTML(node) {
  if (!node) {
    return '';
  }

  if (Array.isArray(node)) {
    node = u('root', node);
  }

  return remark()
    .use(remarkHtml)
    .stringify(node);
}

export const parseToc = async (text, traverse) => {
  const { contents } = await remark()
    .use(function() {
      this.Compiler = root => {
        return cleanTree(root, traverse)
      }
    })
    .process(text)

  return contents
}