JSFiddle - React, Tailwind, and code Playground

JavaScript

Object.prototype.extend = function extend(/* deep, ...src */) {
  var target = this;

  if (typeof target !== 'object' && typeof target !== 'function')
    return;

  var a = arguments,
      deep = false,
      //withGetters = false,
      i = 0,
      l = a.length
  ;

  if (typeof a[0] == 'boolean') {
    deep = a[0];
    i = 1;
  }

  for (var options; i < l; ++i) {
    if ((options = a[i]) == null)
      continue;

    for (var name in options) {
      var src = target[name],
          copy = options[name];

      if (target === copy)
        continue;

      if (deep && copy && typeof copy === 'object' && !copy.nodeType)
        target[name] = (src || (copy.length != null ? [] : {})).extend(deep, copy);
      else if (copy !== undefined)
        target[name] = copy;
    }
  }

  return target;
};


function Promise(executor) {
  if ( !(this instanceof Promise) )
    throw new TypeError("Constructor Promise requires 'new'");

  if ( !(executor instanceof Function) )
    throw new TypeError('Argument 1 of Promise constructor must implement interface Function, '+ (typeof el) +' given');

  var promise = this;

  promise.extend({
    _state: 'pending',
    _reactions: [],
    _heir: null
  });

  var resolvingFunctions = Promise._createResolvingFunctions(promise);

  try {
    var completion = executor(resolvingFunctions.resolve, resolvingFunctions.reject);
  } catch(e) {
    resolvingFunctions.reject(e);
  }

  return promise;
};

Promise.extend({
  _createResolvingFunctions: function(promise) {
    var alreadyResolved = false;

    if ( !(promise instanceof Promise) )
      throw new TypeError('Не лезь сюда, сука');

    var resolve = function(resolution) {
      if (alreadyResolved)
        return;

      alreadyResolved = true;

      if (resolution == promise)
        return reject( new TypeError('self resolution') );

      promise._state = 'resolved';

      Promise._triggerPromiseReactions(promise, resolution);
    };

    var reject = function(reason)...