Turn your ES5 code into readable ES6 (sugar-syntax). It does the opposite of what Babel does.
Latest commit 20e3925 Dec 14, 2016 @nene nene committed on GitHub Merge pull request #201 from FlorianDr/patch-1
Fix typo for 'No transforms specifed'


Build Status License JS.ORG



Lebab transpiles your ES5 code to ES6/ES7. It does exactly the opposite of what Babel does. If you want to understand what Lebab exactly does, try the live demo.


Install it using npm:

$ npm install -g lebab

Convert your old-fashioned code using the lebab cli tool, enabling a specific transformation:

$ lebab es5.js -o es6.js --transform let

Or transform an entire directory of files in-place:

# .js files only
$ lebab --replace src/js/ --transform arrow
# For other file extensions, use explicit globbing
$ lebab --replace 'src/js/**/*.jsx' --transform arrow

For all the possible values for --transform option see the detailed docs below or use --help from command line.

Features and known limitations

The recommended way of using Lebab is to apply one transform at a time, read what exactly the transform does and what are its limitations, apply it for your code and inspect the diff carefully.

Safe transforms

These transforms can be applied with relatively high confidence. They use pretty straight-forward and strict rules for changing the code. The resulting code should be almost 100% equivalent of the original code.

  • arrow - callbacks to arrow functions
    • Converts bound functions like function(){}.bind(this)
    • not applied to unbound functions that use this
    • not applied to functions that use arguments
    • not applied to object properties (use obj-method transform)
    • converts immediate return { return x; } to => x
    • does not remove that = this assignments
    • BUG fails with immediately returning functions that have methods invoked
  • for-of - for loop to for-of loop
  • for-each - for loop to Array.forEach()
  • arg-rest - use of arguments to function(...args)
  • arg-spread - use of apply() to spread operator
    • recognizes obj.method.apply(obj, args)
    • recognizes func.apply(undefined, args)
  • obj-method - function values in object to methods
  • obj-shorthand - {foo: foo} to {foo}
    • ignores numeric and NaN properties
    • does not convert string properties
  • no-strict - removal of "use strict" directives
    • does not touch stuff like x = "use strict";
  • commonjs - CommonJS module definition to ES6 modules
    • converts var foo = require("foo") to import foo from "foo"
    • converts var bar = require("foo").bar to import {bar} from "foo"
    • converts var {bar} = require("foo") to import {bar} from "foo"
    • only handles require() calls in var declarations
    • does not ensure that imported variable is treated as const
    • converts module.exports = <anything> to export default <anything>
    • converts exports.foo = function(){} to export function foo(){}
    • converts exports.Foo = class {} to export class Foo {}
    • converts exports.foo = 123 to export var foo = 123
    • converts exports.foo = bar to export {bar as foo}
    • does not check if named export conflicts with existing variable names
    • does not recognize imports/exports inside nested blocks/functions
  • exponent - Math.pow() to ** operator (ES7)
    • Full support for all new syntax from ES7
  • multi-var - single var x,y; declaration to multiple var x; var y; (refactor)

Unsafe transforms

These transforms should be applied with caution. They either use heuristics which can't guarantee that the resulting code is equivalent of the original code, or they have significant bugs which can result in breaking your code.

Programming API

Simply import and call lebab.transform():

import lebab from 'lebab';
const {code, warnings} = lebab.transform('var f = function(){};', ['let', 'arrow']);
console.log(code); // -> "const f = () => {};"

The warnings will be an array of objects like:

  {line: 12, msg: 'Unable to transform var', type: 'let'},
  {line: 45, msg: 'Can not use arguments in arrow function', type: 'arrow'},

Most of the time there won't be any warnings and the array will be empty.

Editor plugins

Alternatively one can use Lebab through plugins in the following editors:

What's next?

Which feature should Lebab implement next? Let us know by creating an issue or voicing your opinion in existing one.

Want to contribute? Read how Lebab looks for patterns in syntax trees.