Skip to content
a 💩 tool that replaces boring variable names with their fun emoji counterparts
JavaScript HTML
Branch: master
Clone or download
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
bin v1.0.0 Jul 12, 2015
lib
test v1.0.0 Jul 12, 2015
tools v1.0.0 Jul 12, 2015
.gitignore
LICENSE
README.md Update installation instructions Feb 15, 2019
package.json 1.0.1 Jul 12, 2015

README.md

Emojify

Emojify is a useless tool that replaces boring variable names with their fun emoji counterparts. 💩🔥

Install

This package is no longer hosted on npm

Another developer requested the use of the package name emojify, which I happily granted because this is package is useless and will be better suited when attached to a real project. I've decided not to republish it under a new name.

If you still to want to install it for some reason, you can do so by installing directly from this repository.

For command line use:

npm install -g danthareja/emojify

For programmatic use:

npm install danthareja/emojify

Usage

Emojify is a drop-in replacement for UglifyJS2 with one major difference - it minifies your variables by default and replaces them with hilarious emojis.

From the command line, run:

emojify input1.js [input2.js ...] [options]

Anything you can do with UglifyJS2 you can do with Emojify, with a few notable exceptions:

  • --mangle and --beautify are turned on by default
  • You can minify your code a little with --compress (-c) or a lot with --uglify (-u)

Examples

Let's run @mathias's String.fromCodePoint polyfill through some emojification

Our source file: String-fromCodePoint.js

/*! https://mths.be/fromcodepoint v0.2.1 by @mathias */
if (!String.fromCodePoint) {
  (function() {
    var defineProperty = (function() {
      // IE 8 only supports `Object.defineProperty` on DOM elements
      try {
        var object = {};
        var $defineProperty = Object.defineProperty;
        var result = $defineProperty(object, object, object) && $defineProperty;
      } catch(error) {}
      return result;
    }());
    var stringFromCharCode = String.fromCharCode;
    var floor = Math.floor;
    var fromCodePoint = function(_) {
      var MAX_SIZE = 0x4000;
      var codeUnits = [];
      var highSurrogate;
      var lowSurrogate;
      var index = -1;
      var length = arguments.length;
      if (!length) {
        return '';
      }
      var result = '';
      while (++index < length) {
        var codePoint = Number(arguments[index]);
        if (
          !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
          codePoint < 0 || // not a valid Unicode code point
          codePoint > 0x10FFFF || // not a valid Unicode code point
          floor(codePoint) != codePoint // not an integer
        ) {
          throw RangeError('Invalid code point: ' + codePoint);
        }
        if (codePoint <= 0xFFFF) { // BMP code point
          codeUnits.push(codePoint);
        } else { // Astral code point; split in surrogate halves
          // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
          codePoint -= 0x10000;
          highSurrogate = (codePoint >> 10) + 0xD800;
          lowSurrogate = (codePoint % 0x400) + 0xDC00;
          codeUnits.push(highSurrogate, lowSurrogate);
        }
        if (index + 1 == length || codeUnits.length > MAX_SIZE) {
          result += stringFromCharCode.apply(null, codeUnits);
          codeUnits.length = 0;
        }
      }
      return result;
    };
    if (defineProperty) {
      defineProperty(String, 'fromCodePoint', {
        'value': fromCodePoint,
        'configurable': true,
        'writable': true
      });
    } else {
      String.fromCodePoint = fromCodePoint;
    }
  }());
}

Default behavior

Running emojify /path/to/String-fromCodePoint.js outputs:

if (!String.fromCodePoint) {
    (function() {
        var 🚀 = function() {
            try {
                var 🚀 = {};
                var 💩 = Object.defineProperty;
                var 🔥 = 💩(🚀, 🚀, 🚀) && 💩;
            } catch (🍕) {}
            return 🔥;
        }();
        var 💩 = String.fromCharCode;
        var 🔥 = Math.floor;
        var 🍕 = function(🚀) {
            var 🍕 = 16384;
            var 🍔 = [];
            var 🍟;
            var 🍺;
            var 🍻 = -1;
            var 🐒 = arguments.length;
            if (!🐒) {
                return "";
            }
            var 🐶 = "";
            while (++🍻 < 🐒) {
                var 🐱 = Number(arguments[🍻]);
                if (!isFinite(🐱) || 🐱 < 0 || 🐱 > 1114111 || 🔥(🐱) != 🐱) {
                    throw RangeError("Invalid code point: " + 🐱);
                }
                if (🐱 <= 65535) {
                    🍔.push(🐱);
                } else {
                    🐱 -= 65536;
                    🍟 = (🐱 >> 10) + 55296;
                    🍺 = 🐱 % 1024 + 56320;
                    🍔.push(🍟, 🍺);
                }
                if (🍻 + 1 == 🐒 || 🍔.length > 🍕) {
                    🐶 += 💩.apply(null, 🍔);
                    🍔.length = 0;
                }
            }
            return 🐶;
        };
        if (🚀) {
            🚀(String, "fromCodePoint", {
                value: 🍕,
                configurable: true,
                writable: true
            });
        } else {
            String.fromCodePoint = 🍕;
        }
    })();
}

More minification

Running emojify /path/to/String-fromCodePoint.js -o /path/to/String-fromCodePoint.min.js -u outputs:

if(!String.fromCodePoint){(function(){var🚀=function(){try{var🚀={};var💩=Object.defineProperty;var🔥=💩(🚀,🚀,🚀)&&💩}catch(🍕){}return🔥}();var💩=String.fromCharCode;var🔥=Math.floor;var🍕=function(🚀){var🍕=16384;var🍔=[];var🍟;var🍺;var🍻=-1;var🐒=arguments.length;if(!🐒){return""}var🐶="";while(++🍻<🐒){var🐱=Number(arguments[🍻]);if(!isFinite(🐱)||🐱<0||🐱>1114111||🔥(🐱)!=🐱){throw RangeError("Invalid code point: "+🐱)}if(🐱<=65535){🍔.push(🐱)}else{🐱-=65536;🍟=(🐱>>10)+55296;🍺=🐱%1024+56320;🍔.push(🍟,🍺)}if(🍻+1==🐒||🍔.length>🍕){🐶+=💩.apply(null,🍔);🍔.length=0}}return🐶};if(🚀){🚀(String,"fromCodePoint",{value:🍕,configurable:true,writable:true})}else{String.fromCodePoint=🍕}})()}

to a new file located at /path/to/String-fromCodePoint.min.js

Less minification but more emojis

You can go even harder by passing in --mangle-props. This not only replaces top-level variable names but also hunts down properties on objects.

Running emojify /path/to/String-fromCodePoint.js --compress --mangle-props outputs:

String.🚀 || !function() {
    var 🚀 = function() {
        try {
            var 🚀 = {}, 💩 = Object.defineProperty, 🔥 = 💩(🚀, 🚀, 🚀) && 💩;
        } catch (🍕) {}
        return 🔥;
    }(), 💩 = String.fromCharCode, 🔥 = Math.floor, 🍕 = function(🚀) {
        var 🍕, 🍔, 🍟 = 16384, 🍺 = [], 🍻 = -1, 🐒 = arguments.length;
        if (!🐒) return "";
        for (var 🐶 = ""; ++🍻 < 🐒; ) {
            var 🐱 = Number(arguments[🍻]);
            if (!isFinite(🐱) || 0 > 🐱 || 🐱 > 1114111 || 🔥(🐱) != 🐱) throw RangeError("Invalid code point: " + 🐱);
            65535 >= 🐱 ? 🍺.push(🐱) : (🐱 -= 65536, 🍕 = (🐱 >> 10) + 55296, 🍔 = 🐱 % 1024 + 56320, 
            🍺.push(🍕, 🍔)), (🍻 + 1 == 🐒 || 🍺.length > 🍟) && (🐶 += 💩.apply(null, 🍺), 
            🍺.length = 0);
        }
        return 🐶;
    };
    🚀 ? 🚀(String, "fromCodePoint", {
        "💩": 🍕,
        "🔥": !0,
        "🍕": !0
    }) : String.🚀 = 🍕;
}();

More usage

Read up on the rest of the commands here

API Reference

Assuming installation via NPM, you can load Emojify in your application like this:

var Emojify = require("emojify");

There's a single top-level function which combines all the steps. If you don't need additional customization, you might want to go with minify. Example:

var result = Emojify.minify("/path/to/file.js");
console.log(result.code); // minified output
// if you need to pass code instead of file name
var result = Emojify.minify("var b = function () {};", {fromString: true});

You can also compress multiple files:

var result = Emojify.minify([ "file1.js", "file2.js", "file3.js" ]);
console.log(result.code);

Read up on the rest of the programmatic API here

FAQs

Can I run Emojified code?

Nope 😢

While ES6 brings stronger Unicode support to our beloved language, not all symbols can be used as valid identifiers. We can use things like var ಠ_ಠ = 42, but not var 💩 = 43.

@mathias has a great post explaining the details of valid identifiers in ES6

So what's the point?

Maybe one day ESXX will support emoji identifiers. Until then it's just for the lulz 😂

I want my own emojis, the ones you picked suck

You can do that👍

I've exposed the array of characters that Emojify uses to replace your variable names. Simply edit the array in lib/manglers.js with your emojis of choice.

You can include any number of emojis in this array, but I recommend at least 40 different entires for enough combinations to cover a decent sized file. Here's a good site to copy emojis from.

You could grab some of the (more boring) supported characters and produce actualy working code!

Acknowledgements

This project would not exist without UglifyJS. Also, @mathiasbynens is a Unicode beast. I learned so much from his wonderful resources.

You can’t perform that action at this time.