How to use the stylus function in stylus

async transform(code, id) {
      if (!filter(id)) {
        return null;
      }

      const compiledId = `${id}.css`;
      let obj = cache[compiledId];

      if (!obj) {
        // compile Stylus
        const style = stylus(code);
        const relativePath = path.relative(process.cwd(), id);
        style.set('filename', relativePath);
        if (sourceMap) {
          style.set('sourcemap', {inline: true});
        }
        if (fn) {
          style.use(fn);
        }
        const css = await style.render();

        // CSS Modules
        obj = await cssModules.load(css, relativePath, null);

        cache[compiledId] = obj;
      }

new Promise((resolve, reject) => {
      const renderer = stylus(content, {
        filename: id,
        sourcemap: { inline: true }
      })
      renderer.render((err, code) => {
        if (err) {
          return reject(err)
        }
        resolve({ code, map: renderer.sourcemap })
      })
    })

compile: (str, path) => {
        return stylus(str)
          .set('filename', path)
          .set('compress', true);
      }
    })

readFile(path.resolve(path.dirname(file.path), includePath), (error, data) => {
          const css = stylus(data.toString()).render()
          postcss([
            autoprefixer({
              browsers: ['last 2 versions']
            }),
            cssnano
          ])
          .process(css)
          .then(function (result) {
            return callback(`"${result.css}"`)
          })
        })
      }))

const compileStyl = (str, filename) => stylus(str).set('filename', filename).use(nib())
    , bswatchPath = path.resolve(require.resolve('bootswatch/package'), '..', 'dist')

return new Promise((resolve, reject) => {
    stylus(src, {
      compress,
    } as any)
      .include(`${__dirname}/src/style`)
      .include(`${__dirname}/src/style/themes`)
      .use(
        stylusAutoprefixer({
          browsers: pkg.browserslist,
        })
      )
      .render((err: Error | undefined, css: string) =>
        !err ? resolve(css) : reject(err)
      );
  });
}

const compileStyl = (str, filename) =>
    stylus(str)
    .set('filename', filename)
    .set('include css', true)
    .set('compress', app.settings.env == 'production')
    .use(require('nib')())
    .import('nib')

const dCssStyle = debounce((cb) => {
  const ms = Date.now()
  log('updating styles...')

  const input = path.resolve(process.cwd(), 'src/app.styl')
  const output = path.resolve(process.cwd(), 'dist/app.css')

  stylus(fs.readFileSync(input, 'utf8'))
    .set('include css', true)
    .set('hoist atrules', true)
    .use(nib())
    .import(path.resolve(__dirname, '../../node_modules/nib/lib/nib/index.styl'))
    .set('paths', [
      path.resolve(process.cwd(), 'src'),
    ])
    .render((err, css) => {
      if (err) return cb(err)

      fs.writeFileSync(output, css)
      log('styles updated', chalk.dim(`(${Date.now() - ms}ms)`))
      triggerCssRefresh()
    })
}, 300)

readFile (filePath) {
      return fs.readFileSync(filePath, 'utf8')
    },
  }

  function processSourcemap (sourcemap) {
    delete sourcemap.file
    sourcemap.sourcesContent = sourcemap.sources.map(importer.readFile)
    sourcemap.sources = sourcemap.sources.map((filePath) => {
      return parseImportPath(filePath) || filePath
    })

    return sourcemap
  }

  let renderer = stylus(source)
    .use(nib())
    .set('filename', basePath)
    .set('sourcemap', { inline: false, comment: false })
    .set('cache', true)
    .set('importer', importer)

  renderer.render((err, css) => {
    if (err) {
      cb(err, null)
    } else {
      renderer.deps(basePath).forEach(file => dependencyManager.addDependency(file))
      const map = processSourcemap(renderer.sourcemap)
      cb(null, {
        css,
        map,
      })