PHP Decode

<?  "use strict"; 
 
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } 
 
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 
 
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } 
 
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } 
 
var FlipDown = function () { 
  function FlipDown(uts) { 
    var el = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "flipdown"; 
    var opt = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 
 
    _classCallCheck(this, FlipDown); 
 
    if (typeof uts !== "number") { 
      throw new Error("FlipDown: Constructor expected unix timestamp, got ".concat(_typeof(uts), " instead.")); 
    } 
 
    if (_typeof(el) === "object") { 
      opt = el; 
      el = "flipdown"; 
    } 
 
    this.version = "0.3.2"; 
    this.initialised = false; 
    this.now = this._getTime(); 
    this.epoch = uts; 
    this.countdownEnded = false; 
    this.hasEndedCallback = null; 
    this.element = document.getElementById(el); 
    this.rotors = []; 
    this.rotorLeafFront = []; 
    this.rotorLeafRear = []; 
    this.rotorTops = []; 
    this.rotorBottoms = []; 
    this.countdown = null; 
    this.daysRemaining = 0; 
    this.clockValues = {}; 
    this.clockStrings = {}; 
    this.clockValuesAsString = []; 
    this.prevClockValuesAsString = []; 
    this.opts = this._parseOptions(opt); 
 
    this._setOptions(); 
 
    //console.log("FlipDown ".concat(this.version, " (Theme: ").concat(this.opts.theme, ")")); 
  } 
 
  _createClass(FlipDown, [{ 
    key: "start", 
    value: function start() { 
      if (!this.initialised) this._init(); 
      this.countdown = setInterval(this._tick.bind(this), 1000); 
      return this; 
    } 
  }, { 
    key: "ifEnded", 
    value: function ifEnded(cb) { 
      this.hasEndedCallback = function () { 
        cb(); 
        this.hasEndedCallback = null; 
      }; 
 
      return this; 
    } 
  }, { 
    key: "_getTime", 
    value: function _getTime() { 
      return new Date().getTime() / 1000; 
    } 
  }, { 
    key: "_hasCountdownEnded", 
    value: function _hasCountdownEnded() { 
      if (this.epoch - this.now < 0) { 
        this.countdownEnded = true; 
 
        if (this.hasEndedCallback != null) { 
          this.hasEndedCallback(); 
          this.hasEndedCallback = null; 
        } 
 
        return true; 
      } else { 
        this.countdownEnded = false; 
        return false; 
      } 
    } 
  }, { 
    key: "_parseOptions", 
    value: function _parseOptions(opt) { 
      var headings = ["Days", "Hours", "Minutes", "Seconds"]; 
 
      if (opt.headings && opt.headings.length === 4) { 
        headings = opt.headings; 
      } 
 
      return { 
        theme: opt.hasOwnProperty("theme") ? opt.theme : "dark", 
        headings: headings 
      }; 
    } 
  }, { 
    key: "_setOptions", 
    value: function _setOptions() { 
      this.element.classList.add("flipdown__theme-".concat(this.opts.theme)); 
    } 
  }, { 
    key: "_init", 
    value: function _init() { 
      this.initialised = true; 
 
      if (this._hasCountdownEnded()) { 
        this.daysremaining = 0; 
      } else { 
        this.daysremaining = Math.floor((this.epoch - this.now) / 86400).toString().length; 
      } 
 
      var dayRotorCount = this.daysremaining <= 2 ? 2 : this.daysremaining; 
 
      for (var i = 0; i < dayRotorCount + 6; i++) { 
        this.rotors.push(this._createRotor(0)); 
      } 
 
      var dayRotors = []; 
 
      for (var i = 0; i < dayRotorCount; i++) { 
        dayRotors.push(this.rotors[i]); 
      } 
 
      this.element.appendChild(this._createRotorGroup(dayRotors, 0)); 
      var count = dayRotorCount; 
 
      for (var i = 0; i < 3; i++) { 
        var otherRotors = []; 
 
        for (var j = 0; j < 2; j++) { 
          otherRotors.push(this.rotors[count]); 
          count++; 
        } 
 
        this.element.appendChild(this._createRotorGroup(otherRotors, i + 1)); 
      } 
 
      this.rotorLeafFront = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-leaf-front")); 
      this.rotorLeafRear = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-leaf-rear")); 
      this.rotorTop = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-top")); 
      this.rotorBottom = Array.prototype.slice.call(this.element.getElementsByClassName("rotor-bottom")); 
 
      this._tick(); 
 
      this._updateClockValues(true); 
 
      return this; 
    } 
  }, { 
    key: "_createRotorGroup", 
    value: function _createRotorGroup(rotors, rotorIndex) { 
      var rotorGroup = document.createElement("div"); 
      rotorGroup.className = "rotor-group"; 
      var dayRotorGroupHeading = document.createElement("div"); 
      dayRotorGroupHeading.className = "rotor-group-heading"; 
      dayRotorGroupHeading.setAttribute("data-before", this.opts.headings[rotorIndex]); 
      rotorGroup.appendChild(dayRotorGroupHeading); 
      appendChildren(rotorGroup, rotors); 
      return rotorGroup; 
    } 
  }, { 
    key: "_createRotor", 
    value: function _createRotor() { 
      var v = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 
      var rotor = document.createElement("div"); 
      var rotorLeaf = document.createElement("div"); 
      var rotorLeafRear = document.createElement("figure"); 
      var rotorLeafFront = document.createElement("figure"); 
      var rotorTop = document.createElement("div"); 
      var rotorBottom = document.createElement("div"); 
      rotor.className = "rotor"; 
      rotorLeaf.className = "rotor-leaf"; 
      rotorLeafRear.className = "rotor-leaf-rear"; 
      rotorLeafFront.className = "rotor-leaf-front"; 
      rotorTop.className = "rotor-top"; 
      rotorBottom.className = "rotor-bottom"; 
      rotorLeafRear.textContent = v; 
      rotorTop.textContent = v; 
      rotorBottom.textContent = v; 
      appendChildren(rotor, [rotorLeaf, rotorTop, rotorBottom]); 
      appendChildren(rotorLeaf, [rotorLeafRear, rotorLeafFront]); 
      return rotor; 
    } 
  }, { 
    key: "_tick", 
    value: function _tick() { 
      this.now = this._getTime(); 
      var diff = this.epoch - this.now <= 0 ? 0 : this.epoch - this.now; 
      this.clockValues.d = Math.floor(diff / 86400); 
      diff -= this.clockValues.d * 86400; 
      this.clockValues.h = Math.floor(diff / 3600); 
      diff -= this.clockValues.h * 3600; 
      this.clockValues.m = Math.floor(diff / 60); 
      diff -= this.clockValues.m * 60; 
      this.clockValues.s = Math.floor(diff); 
 
      this._updateClockValues(); 
 
      this._hasCountdownEnded(); 
    } 
  }, { 
    key: "_updateClockValues", 
    value: function _updateClockValues() { 
      var _this = this; 
 
      var init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false; 
      this.clockStrings.d = pad(this.clockValues.d, 2); 
      this.clockStrings.h = pad(this.clockValues.h, 2); 
      this.clockStrings.m = pad(this.clockValues.m, 2); 
      this.clockStrings.s = pad(this.clockValues.s, 2); 
      this.clockValuesAsString = (this.clockStrings.d + this.clockStrings.h + this.clockStrings.m + this.clockStrings.s).split(""); 
      this.rotorLeafFront.forEach(function (el, i) { 
        el.textContent = _this.prevClockValuesAsString[i]; 
      }); 
      this.rotorBottom.forEach(function (el, i) { 
        el.textContent = _this.prevClockValuesAsString[i]; 
      }); 
 
      function rotorTopFlip() { 
        var _this2 = this; 
 
        this.rotorTop.forEach(function (el, i) { 
          if (el.textContent != _this2.clockValuesAsString[i]) { 
            el.textContent = _this2.clockValuesAsString[i]; 
          } 
        }); 
      } 
 
      function rotorLeafRearFlip() { 
        var _this3 = this; 
 
        this.rotorLeafRear.forEach(function (el, i) { 
          if (el.textContent != _this3.clockValuesAsString[i]) { 
            el.textContent = _this3.clockValuesAsString[i]; 
            el.parentElement.classList.add("flipped"); 
            var flip = setInterval(function () { 
              el.parentElement.classList.remove("flipped"); 
              clearInterval(flip); 
            }.bind(_this3), 500); 
          } 
        }); 
      } 
 
      if (!init) { 
        setTimeout(rotorTopFlip.bind(this), 500); 
        setTimeout(rotorLeafRearFlip.bind(this), 500); 
      } else { 
        rotorTopFlip.call(this); 
        rotorLeafRearFlip.call(this); 
      } 
 
      this.prevClockValuesAsString = this.clockValuesAsString; 
    } 
  }]); 
 
  return FlipDown; 
}(); 
 
function pad(n, len) { 
  n = n.toString(); 
  return n.length < len ? pad("0" + n, len) : n; 
} 
 
function appendChildren(parent, children) { 
  children.forEach(function (el) { 
    parent.appendChild(el); 
  }); 
} 
 ?>