list of transforms (original) (raw)

Here is a list of browserify transforms:

You should also consult the packages on npm with the browserify-transform tag.

• aliasify - remap require calls at build time.
• babelify (formerly "6to5ify") - turn ES6+ code into readable vanilla ES5 with source maps
• blissify - compile .html files written using bliss
• bpb - browserify transform to safely replace process.browser with true by working on the Abstract Syntax Tree (AST)
• brfs - inline fs.readFileSync() calls with file contents
• browserify-casesensitiverequire - Emits warnings if the same file is require()'d using different casing from different files (causing it to build the same file multiple times on Windows, same code would fail on linux)
• browserify-compile-templates - require .html file snippets to precompile Underscore templates.
• browserify-cdnjs - Browserify transform to require libraries from jsDelivr
• browserify-css - transform for bundling, rebasing, inlining, and minifying CSS files
• browserify-istanbul - a transform for the istanbul code coverage tool
• browserify-markdown - compile markdown for the browser
• browserify-ng-html2js - compile angular templates into angular modules.
• browserify-package-json - remove not public values from package.json
• browserify-postcss - PostCSS precompiler and CSS handler. require the contents of CSS files as a string and/or automatically inject them into a document at runtime.
• browserify-shim - make commonJS-incompatible libraries/files browserifyable
• Browserify Substitution Mass Confusion — Makes the browser field in package.json work in nested dependencies.
• browserify-window-context - sets Window context to a shimmed module
• browserify-swap - swaps out modules according to a config in your package.json selected via an environment variable
• browserify-versionify - Browserify transform to replace placeholder with package version
• bulkify - bulk require whole directories into nested objects using globs
• cacheify - wraps around other transforms, caching their results to speed up bundling.
• caching-coffeeify - coffeeify version that caches previously compiled files to optimize the compilation step
• cocoify - transform for coco, unfancy coffeescript
• coffee-reactify - compile .coffee and .cjsx files with CJSX (a superset of coffeescript used with the react UI library) to javascript
• coffeeify - compile .coffee files to javascript automatically
• combynify - precompile combyne templates
• commandify - executes a command whenever the bundle is created
• concatenify - concatenate files into a bundle
• configurify - evaluate dynamic expressions on the server and expose the result as static snapshot
• continuatify - a compiler for JavaScript asynchronous Continuation-Passing Style transformation (continuation.js)
• cssify - require .css files to add styles to the page
• cssnextify - require css & cssnext
• css-modulesify - locally-scope your css with CSS Modules.
• csvify - CSV and TSV transformations
• dbify - inline the results of database queries
• deAMDify - translate AMD modules to Node-style modules automatically
• deassertify - comment 'assert' statements out of your production code.
• debowerify - use bower client packages more easily with browserify.
• decomponentify - use component client packages seamlessly with browserify.
• deproptypeify - analyzes your code to strip out .propTypes declarations (React components); useful for production builds of bundled code
• detabbify - strip tabs and replace them with spaces
• detachkify - allow usage of absolute paths in require statements
• dustify - converts Dust.js templates to JavaScript modules.
• envify - Selectively replace Node-style environment variables (process.env) with plain strings.
• envlocalify - Selectively replace Node-style environment variables (process.env) with plain strings, but loads them from specified files
• es6ify - compile ES6 files to ES5 javascript automatically
• eslintify - applies eslint, respecting .eslintrc and .eslintignore
• espowerify - Weave power-assert feature into test code.
• exposify expose globals added via a script tag as modules so they can be required (used by browserify-shim)
• extensify - require files other than .js without specifying the extension (e.g .jsx files)
• falafelify Run your modules through falafel while bundling.
• folderify - inline content of a directory imported using include-folder. Files content is inlined using brfs
• forgetify - invalidate files from the Browserify cache
• glslify - use npm modules in WebGL GLSL shaders
• gorillaify - compile .gs(gorillascript) files to javascript automatically
• gppfy - HTML and JS preprocessor based on GPP
• graspify - replace code via grasp
• haribotify - merges HTML files and require it
• hbsfy - precompile handlebars templates to javascript functions automatically
• hintify - applies jshint, respecting .jshintrc and .jshintignore
• html-minifyify - Inline calls to html-minifier.
• html2js - Turn crummy HTML into beautiful Javascript: var myHtml = require('./my.html').
• icsify - compile .iced IcedCoffeeScript files to javascript automatically
• installify - automatically installs your missing dependencies for you.
• jadeify - include Jade files as compiled js templates.
• jedify - transform po files to Jed instances.
• jisonify - include Jison parsers in your project
• jstify - require .jst/.tpl files to precompile Underscore and Lo-Dash templates (with HTML minification)
• jstransformify - apply source to source AST transformations and generate source maps for them
• lessify - LESS precompiler and CSS plugin
• less-modulesify - browserify plugin support css module for less
• licensify - prepend license header to your bundle (Actually a plugin, not a transform.)
• lispyscriptify - require .ls files to import Lispyscript
• liveify - compile livescript files to javascript automatically
• loaderify - run operations on the contents of require()'d files, based on the filename. Similar to webpack loaders.
• mithrilify - converting Mithril view templates based on msx
• mithril-objectify - optimize Mithril m(<tag>) function calls into static objects
• modcss - turn CSS or Stylus into JSON for React components
• modular-css - Streamlined CSS Modules implementation
• ngify - load HTML files into Angular's $templateCache and eliminate hard Angular dependency in JavaScript files by using annotations.
• nunjucksify - precompile nunjucks templates.
• package-json-versionify - require('./package.json').version and strip everything else from package.json.
• partialify - require()-able HTML, CSS, JSON and (potentially) more
• pathmodify - Rewrite (alias, map) require() calls to avoid ../ and ./ relative paths and still use programmatic transforms. Also dynamically control module exposure. (Actually a plugin, not a transform.)
• phantomjsify - shim out node.js core for PhantomJS
• pkgify - more efficient and extensive alternative to aliasify and remapify
• pogoify - compile pogoscript files.
• ractivate - pre-parse Ractive.js templates
• reactify - compile JSX (superset of javascript used in react UI library) files to javascript
• redirectify - redirect require statements during bundle() if specified override folder is found
• require-globify - require many js files easily with globbing expressions
• requirish - tool for avoiding the ../../../ relative paths problem and includes a browserify-transform to rewrites require() for browser
• rewireify - a port of Rewire that adds setter and getter methods to each module so that their behaviour can be modified for better unit testing.
• rfileify - inline rfile(path) calls with file contents (also supports ruglify and any other rfile derivatives)
• rfolderify - turn calls to rfolder into a map of requires of the files in the thing
• riotify - pre-compile Riot.js templates
• scssify - Sass transform. require the contents of Sass files as a string and optionally inject them into a document using a link or style tag. Plus watchify support!
• sassify - SASS precompiler and CSS handler. require the contents of (S)CSS files as a string and/or automatically inject them into a document at runtime by using the option --auto-inject.
• shortify - rewrites require('./foo/../baz') to require('./../../foo/bar/../baz') or however defined per options
• stringify - require() text files (templates) inside of your client-side JavaScript files.
• stripify - strip console.log lines from your code
• stylify - for Stylus
• sveltify - require Svelte components
• svg-reactify - transform SVG files into React elements.
• sweetify - transform for loading and transforming code with Sweet.js macros
• swcify - process files with SWC compiler.
• swigify - precompiles include and extends tags in swig templates
• transfigurify - configure which transforms get applied to your package via an environment variable
• turn - minimal modules for a hypothetical es6 with lua's return
• tsify - compile typescript files to javascript
• tscriptify - typescript transform
• unassertify - remove assertions from code to encourage Design by Contract (DbC)
• unflowify - remove Flow type annotations
• unreachable-branch-transform - comments out unreachable code branches in if statements, ternaries ?, and logical operations || &&
• varify - converts all const assignments to var assignments.
• vee-cee-ellify - injects styles compiled from styl files using vcl's preprocessor
• viralify - injects browserify transforms into specified dependencies of a package recursively
• vueify - transform for Vue.js components, with scoped CSS and component hot-reloading.
• yamlify - YAML support for browserify and node.js
• weexify - Weex support for browserify