npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details


  • User packages



Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.


Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner




The easiest way to compile JavaScript, HTML and CSS





npm version build status downloads js-standard-style

The easiest way to compile JavaScript, HTML and CSS.

We want people to have fun building things for the web. There should be no hurdles between a great idea, and your first prototype. And once you're ready, it should be easy to package it up and share it online. That's Bankai: a tool that helps you build for the web. No configuration, and no hassle - that's our promise.

If this is your first time building something for the web, take a look at choojs/create-choo-app to help get a project setup from scratch :sparkles:.


  $ bankai <command> [entry] [options]


    build       compile all files to dist/
    inspect     inspect the bundle dependencies
    start       start a development server


    -d, --debug       output lots of logs
    -h, --help        print usage
    -q, --quiet       don't output any logs
    -v, --version     print version


    Start a development server
    $ bankai start index.js

    Visualize all dependencies in your project
    $ bankai inspect index.js

    Compile all files in the project to disk
    $ bankai build index.js

  Running into trouble? Feel free to file an issue:

  Do you enjoy using this software? Become a backer:

⚠️ HTTPS Instructions

When you first open up your application in a browser, you'll probably see a warning page about HTTPS connections being untrusted. No worries, this is entirely expected behavior. Follow the instructions below to solve this for your browser.

HTTPS is needed for an increasing amount of APIs to work in the browser. For example if you want to test HTTP/2 connections or use parts of the storage API, you have no choice but to use an HTTPS connection on localhost. That's why we try and make this work as efficiently, and securely as possible.

We generate a unique certificate for each Bankai installation. This means that you'll only need to trust an HTTPS certificate for Bankai once. This should be secure from remote attackers, because unless they have successfully acquired access to your machine's filesystem, they won't be able to replicate the certificate.

A wild security screen appears!. Click on "advanced".


Bankai applies lots of optimizations to projects. Generally you won't need to care how we do this: it's lots of glue code, and not necessarily pretty. But it can be useful to know which optimizations we apply. This is a list:


  • nanohtml: Optimize choo HTML code so it runs significantly faster in the browser.
  • glslify: Adds a module system to GLSL shaders.
  • brfs: Statically inline calls to fs.readFile(). Useful to ship assets in the browser.
  • envify: Allow environment variables to be used in the bundle. Especially useful in combination with minification, which removes unused code paths.
  • split-require: Lazy load parts of your application using the require('split-require') function.
  • babelify: Bring the latest browser features to all browsers. See our babel section for more details.

And bankai uses tinyify, which adds the following optimizations:

  • browser-pack-flat: Remove function wrappers from the bundle, making the result faster to run and easier to minify.
  • bundle-collapser: Remove all pathnames from inside the bundle, and replace them with IDs. This not only makes bundles smaller, it prevents details from your local dev setup leaking.
  • common-shakeify: Remove unused JavaScript code from the bundle. Best known as dead code elimination or tree shaking.
  • unassertify: Remove all require('assert') statements from the code. Only applied for production builds.
  • uglifyify: Minify the bundle.


  • sheetify: extract all inline CSS from JavaScript, and include it in bundle.js.
  • purifyCSS: removes unused CSS from the project.
  • cleanCSS: minify the bundle.


  • inline-critical-css: extract all crititical CSS for a page into the <head> of the document. This means that every page will be able to render after the first roundtrip, which makes for super snappy pages.
  • async load scripts: loads scripts in the background using the defer attribute.
  • async load styles: loads styles in the background using the preload attribute.
  • async load styles: preloads fonts in the background using the preload attribute.
  • server render: server renders Choo applications. We're welcome to supporting other frameworks too. PRs welcome!
  • manifest: includes a link to manifest.json so the application can be installed on mobile.
  • viewport: defines the right viewport dimensions to make applications accessible for everyone.
  • theme color: sets the theme color defined in manifest.json so the navigator bar on mobile is styled on brand.
  • title: sets the right title on a page. Either extracts it from the application (choo only, for now) or uses whatever the title is in manifest.json.
  • live reload: during development, we inject a live reload script.


The Bankai CLI doesn't take any flags, other than to manipulate how we log to the console. Configuring Bankai is done by modifying package.json.

Bankai is built on three technologies: browserify, sheetify, and documentify. Because these can be configured inside package.json it means that Bankai itself can be configured from there too. Also if people ever decide to switch from the command line to JavaScript, no extra configuration is needed.

  "name": "my-app",
  "browserify": {
     "transform": [
   "sheetify": {
     "transform": [
   "documentify": {
     "transform": [

Custom HTML

By default, Bankai starts with an empty HTML document, injecting the tags mentioned above. You can also create a custom template as index.html, and Bankai will inject tags into it instead.

If you export your Choo app instance after doing .mount(), Bankai respects the mount location during server side rendering:

// app.js
module.exports = app.mount('#app')
<!-- index.html -->
  <div id="app"></div>
  <div id="footer">© 2018</div>

Injecting headers - favicon.ico, CDNs, manifests etc...

You might be looking to use some of the fantastic third party libraries or tools out there. Take the font-awesome library for example, but there are plenty of others. To do so, you typically need to include additional css or js libraries in your <head>. And you can do this by setting up your documentify transform.

In this example, you will need to add a "documentify" transform which specifies a js file used, but you will also need a couple of extra npm libraries which you can install with:

npm i hstream dedent

Now in package.json, add the following transform:

"documentify": {
    "transform": [
          "order": "end"

In this example, we are storing the transform in a folder called lib, which you will need to create, and create a document.js file in it. Edit the file called document.js and put the following transform code in it:

var dedent = require('dedent')
var hyperstream = require('hstream')

module.exports = document

function document () {
  return hyperstream({
    'meta[name="viewport"]': {
      content: 'width=device-width, initial-scale=1, viewport-fit=cover'
    head: {
      _prependHtml: dedent`
      <link rel="manifest" href="manifest.json">
      <link rel="stylesheet" href="">
      _appendHtml: dedent`
        <link rel="shortcut icon" href="/favicon.ico">

This example now enables Bankai to generate an index.html file which has a link to the font-awesome css cdn, a manifest.json file, and a favicon.ico file ready for deployment.

Service Workers

Bankai comes with support for service workers. You can place a service worker entry point in a file called sw.js or service-worker.js. Bankai will output a browserify bundle by the same name.

You can easily register service workers using choo-service-worker:


choo-service-worker defaults to /sw.js for the service worker file name. If you named your service worker service-worker.js instead, do:


Service workers have access to some environment variables:

  • process.env.STYLE_LIST: An array of URLs to stylesheet files.
  • process.env.SCRIPT_LIST: An array of URLs to script files.
  • process.env.ASSET_LIST: An array of URLs to assets.
  • process.env.DOCUMENT_LIST: An array of URLs to server-rendered routes.
  • process.env.MANIFEST_LIST: An array containing the URL to the manifest file.
  • process.env.FILE_LIST: An array of URLs to assets and routes. This can be used to add all your app's files to a service worker cache.


Bankai can be hooked up directly to an HTTP server, which is useful when working on full stack code.

var bankai = require('bankai/http')
var http = require('http')
var path = require('path')

var compiler = bankai(path.join(__dirname, 'client.js'))
var server = http.createServer(function (req, res) {
  compiler(req, res, function () {
    res.statusCode = 404
    res.end('not found')

server.listen(8080, function () {
  console.log('listening on port 8080')


Not all browsers support all of the Web Platform's features. So in order to use newer features on older browsers, we have to find a solution. The best solution out there at the moment is Babel.

Babel is a plugin-based JavaScript compiler. It takes JavaScript in, and outputs JavaScript based for the platforms you've decided to target. In Bankai we target the last 2 versions of FireFox, Chrome and Edge, and every other browser that's used by more than 1% of people on earth. This includes IE11. And if you have different opinions on which browsers to use, Bankai respects .babelrc and .browserslistrc files.

Some newer JavaScript features require loading an extra library; async/await being the clearest example. To enable such features, the babel-polyfill library needs to be included in your application's root (e.g. index.js).


We don't include this file by default in Bankai, because it has a significant size overhead. Once Babel includes only the language features you're using, we'll work to include babel-polyfill by default.


compiler.on('error', callback(nodeName, edgeName, error))

Whenever an internal error occurs.

compiler.on('change', callback(nodeName, edgeName, state))

Whenever a change in the internal graph occurs.


compiler = bankai(entry, [opts])

Create a new bankai instance. Takes a path to a JavaScript file as the first argument. The following options are available:

  • opts.quiet: Defaults to false. Don't output any data to stdout. Useful if you have your own logging system.
  • Defaults to true. Watch for changes in the source files and rebuild. Set to false to get optimized bundles.
  • babelifyDeps: Defaults to true. Transform dependencies with babelify.

compiler.documents(routename, [opts], done(err, { buffer, hash }))

Output an HTML bundle for a route. Routes are determined based on the project's router. Pass '/' to get the default route.

  • opts.state: Will be passed the render function for the route, and inlined in the <head> of the body as window.initialState.

compiler.scripts(filename, done(err, { buffer, hash }))

Pass in a filename and output a JS bundle.

compiler.assets(assetName, done(err, { buffer, hash }))

Output any other file besides JS, CSS or HTML.

compiler.styles(name, done(err, { buffer, hash }))

Output a CSS bundle.

compiler.manifest(done(err, { buffer, hash }))

Output a manifest.json.

compiler.serviceWorker(done(err, { buffer, hash }))

Output a service worker.


Close all file watchers.


Apache License 2.0