JavaScript
Turn your ES5 code into readable ES6 (sugar-syntax). It does the opposite of what Babel does.

Lebab

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

Usage

Install it using npm:

$ npm install -g lebab

Transpile your old-fashioned code using the lebab cli tool.

$ lebab es5.js -o es6.js

Or convert just the features of your choice:

$ lebab es5.js -o es6.js --enable let,arrow,commonjs

Features and known limitations

Lebab is not magic. It uses heuristics to figure out likely ES6 equivalent, but it doesn't guarantee that the resulting code is 100% equivalent.

Therefore 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.

• class - function/prototypes to classes
  • recognizes Foo.prototype.method = function(){ ... };
  • recognizes Foo.prototype = { ...methods... };
  • recognizes getters/setters defined with Object.defineProperty()
  • does not recognize classes without methods
  • does not recognize static methods
  • no support for extending classes
  • BUG does not support namespaced classes
  • BUG class and method comments are not preserved
• template - string concatenation to template strings
  • converts variables and arbitrary expressions to ${...}
  • BUG removes indentation of multi-line strings
  • LIMITATION ignores difference between .toString() and .valueOf()
• 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
• let - var to let/const
  • never modified variables are converted to const
  • properly recognizes block-scoping
  • vars that conflict with block-scoping are not converted
  • BUG treats existing let/const as var
  • BUG does not recognize destructuring
• default-param - default parameters instead of a = a || 2
  • recognizes a = a || 2
  • recognizes a = a ? a : 2
  • recognizes a = a === undefined ? 2 : a
  • recognizes a = typeof a === 'undefined' ? 2 : a
  • LIMITATION transforming a = a || 2 does produce strictly equivalent code
• 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
  • does not convert named function expressions
  • does not convert arrow-functions
• 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

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.