w0bm.com v1.5z FULL.RETARD.BUILD.BUT.STILL.WORKS

public/njum/css/bootstrap-tagsinput.css

@@ -0,0 +1,55 @@
+.bootstrap-tagsinput {
+  background-color: #fff;
+  border: 1px solid #ccc;
+  box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.075);
+  display: inline-block;
+  padding: 4px 6px;
+  color: #555;
+  vertical-align: middle;
+  border-radius: 4px;
+  max-width: 100%;
+  line-height: 22px;
+  cursor: text;
+}
+.bootstrap-tagsinput input {
+  border: none;
+  box-shadow: none;
+  outline: none;
+  background-color: transparent;
+  padding: 0 6px;
+  margin: 0;
+  width: auto;
+  max-width: inherit;
+}
+.bootstrap-tagsinput.form-control input::-moz-placeholder {
+  color: #777;
+  opacity: 1;
+}
+.bootstrap-tagsinput.form-control input:-ms-input-placeholder {
+  color: #777;
+}
+.bootstrap-tagsinput.form-control input::-webkit-input-placeholder {
+  color: #777;
+}
+.bootstrap-tagsinput input:focus {
+  border: none;
+  box-shadow: none;
+}
+.bootstrap-tagsinput .tag {
+  margin-right: 2px;
+  color: white;
+}
+.bootstrap-tagsinput .tag [data-role="remove"] {
+  margin-left: 8px;
+  cursor: pointer;
+}
+.bootstrap-tagsinput .tag [data-role="remove"]:after {
+  content: "x";
+  padding: 0px 2px;
+}
+.bootstrap-tagsinput .tag [data-role="remove"]:hover {
+  box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.2), 0 1px 2px rgba(0, 0, 0, 0.05);
+}
+.bootstrap-tagsinput .tag [data-role="remove"]:hover:active {
+  box-shadow: inset 0 3px 5px rgba(0, 0, 0, 0.125);
+}

public/njum/css/commento.css

@@ -0,0 +1,3 @@
+body {
+	background: black;
+}

public/njum/css/perfect-scrollbar.css

@@ -0,0 +1,116 @@
+/*
+ * Container style
+ */
+.ps {
+  overflow: hidden !important;
+  overflow-anchor: none;
+  -ms-overflow-style: none;
+  touch-action: auto;
+  -ms-touch-action: auto;
+}
+
+/*
+ * Scrollbar rail styles
+ */
+.ps__rail-x {
+  display: none;
+  opacity: 0;
+  transition: background-color .2s linear, opacity .2s linear;
+  -webkit-transition: background-color .2s linear, opacity .2s linear;
+  height: 15px;
+  /* there must be 'bottom' or 'top' for ps__rail-x */
+  bottom: 0px;
+  /* please don't change 'position' */
+  position: absolute;
+}
+
+.ps__rail-y {
+  display: none;
+  opacity: 0;
+  transition: background-color .2s linear, opacity .2s linear;
+  -webkit-transition: background-color .2s linear, opacity .2s linear;
+  width: 15px;
+  /* there must be 'right' or 'left' for ps__rail-y */
+  right: 0;
+  /* please don't change 'position' */
+  position: absolute;
+}
+
+.ps--active-x > .ps__rail-x,
+.ps--active-y > .ps__rail-y {
+  display: block;
+  background-color: transparent;
+}
+
+.ps:hover > .ps__rail-x,
+.ps:hover > .ps__rail-y,
+.ps--focus > .ps__rail-x,
+.ps--focus > .ps__rail-y,
+.ps--scrolling-x > .ps__rail-x,
+.ps--scrolling-y > .ps__rail-y {
+  opacity: 0.6;
+}
+
+.ps .ps__rail-x:hover,
+.ps .ps__rail-y:hover,
+.ps .ps__rail-x:focus,
+.ps .ps__rail-y:focus,
+.ps .ps__rail-x.ps--clicking,
+.ps .ps__rail-y.ps--clicking {
+  background-color: #eee;
+  opacity: 0.9;
+}
+
+/*
+ * Scrollbar thumb styles
+ */
+.ps__thumb-x {
+  background-color: #aaa;
+  border-radius: 6px;
+  transition: background-color .2s linear, height .2s ease-in-out;
+  -webkit-transition: background-color .2s linear, height .2s ease-in-out;
+  height: 6px;
+  /* there must be 'bottom' for ps__thumb-x */
+  bottom: 2px;
+  /* please don't change 'position' */
+  position: absolute;
+}
+
+.ps__thumb-y {
+  background-color: #aaa;
+  border-radius: 6px;
+  transition: background-color .2s linear, width .2s ease-in-out;
+  -webkit-transition: background-color .2s linear, width .2s ease-in-out;
+  width: 6px;
+  /* there must be 'right' for ps__thumb-y */
+  right: 2px;
+  /* please don't change 'position' */
+  position: absolute;
+}
+
+.ps__rail-x:hover > .ps__thumb-x,
+.ps__rail-x:focus > .ps__thumb-x,
+.ps__rail-x.ps--clicking .ps__thumb-x {
+  background-color: #999;
+  height: 11px;
+}
+
+.ps__rail-y:hover > .ps__thumb-y,
+.ps__rail-y:focus > .ps__thumb-y,
+.ps__rail-y.ps--clicking .ps__thumb-y {
+  background-color: #999;
+  width: 11px;
+}
+
+/* MS supports */
+@supports (-ms-overflow-style: none) {
+  .ps {
+    overflow: auto !important;
+  }
+}
+
+@media screen and (-ms-high-contrast: active), (-ms-high-contrast: none) {
+  .ps {
+    overflow: auto !important;
+  }
+}

public/njum/css/simplebar.css

@@ -0,0 +1,190 @@
+[data-simplebar] {
+  position: relative;
+  flex-direction: column;
+  flex-wrap: wrap;
+  justify-content: flex-start;
+  align-content: flex-start;
+  align-items: flex-start;
+}
+
+.simplebar-wrapper {
+  overflow: hidden;
+  width: inherit;
+  height: inherit;
+  max-width: inherit;
+  max-height: inherit;
+}
+
+.simplebar-mask {
+  direction: inherit;
+  position: absolute;
+  overflow: hidden;
+  padding: 0;
+  margin: 0;
+  left: 0;
+  top: 0;
+  bottom: 0;
+  right: 0;
+  width: auto !important;
+  height: auto !important;
+  z-index: 0;
+}
+
+.simplebar-offset {
+  direction: inherit !important;
+  box-sizing: inherit !important;
+  resize: none !important;
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  right: 0;
+  padding: 0;
+  margin: 0;
+  -webkit-overflow-scrolling: touch;
+}
+
+.simplebar-content-wrapper {
+  direction: inherit;
+  box-sizing: border-box !important;
+  position: relative;
+  display: block;
+  height: 100%; /* Required for horizontal native scrollbar to not appear if parent is taller than natural height */
+  width: auto;
+  visibility: visible;
+  overflow: auto; /* Scroll on this element otherwise element can't have a padding applied properly */
+  max-width: 100%; /* Not required for horizontal scroll to trigger */
+  max-height: 100%; /* Needed for vertical scroll to trigger */
+}
+
+.simplebar-content:before,
+.simplebar-content:after {
+  content: ' ';
+  display: table;
+}
+
+.simplebar-placeholder {
+  max-height: 100%;
+  max-width: 100%;
+  width: 100%;
+  pointer-events: none;
+}
+
+.simplebar-height-auto-observer-wrapper {
+  box-sizing: inherit !important;
+  height: 100%;
+  width: 100%;
+  max-width: 1px;
+  position: relative;
+  float: left;
+  max-height: 1px;
+  overflow: hidden;
+  z-index: -1;
+  padding: 0;
+  margin: 0;
+  pointer-events: none;
+  flex-grow: inherit;
+  flex-shrink: 0;
+  flex-basis: 0;
+}
+
+.simplebar-height-auto-observer {
+  box-sizing: inherit;
+  display: block;
+  opacity: 0;
+  position: absolute;
+  top: 0;
+  left: 0;
+  height: 1000%;
+  width: 1000%;
+  min-height: 1px;
+  min-width: 1px;
+  overflow: hidden;
+  pointer-events: none;
+  z-index: -1;
+}
+
+.simplebar-track {
+  z-index: 1;
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  pointer-events: none;
+  overflow: hidden;
+}
+
+[data-simplebar].simplebar-dragging .simplebar-track {
+  pointer-events: all;
+}
+
+.simplebar-scrollbar {
+  position: absolute;
+  right: 2px;
+  width: 7px;
+  min-height: 10px;
+}
+
+.simplebar-scrollbar:before {
+  position: absolute;
+  content: '';
+  background: black;
+  border-radius: 7px;
+  left: 0;
+  right: 0;
+  opacity: 0;
+  transition: opacity 0.2s linear;
+}
+
+.simplebar-track .simplebar-scrollbar.simplebar-visible:before {
+  /* When hovered, remove all transitions from drag handle */
+  opacity: 0.5;
+  transition: opacity 0s linear;
+}
+
+.simplebar-track.simplebar-vertical {
+  top: 0;
+  width: 11px;
+}
+
+.simplebar-track.simplebar-vertical .simplebar-scrollbar:before {
+  top: 2px;
+  bottom: 2px;
+}
+
+.simplebar-track.simplebar-horizontal {
+  left: 0;
+  height: 11px;
+}
+
+.simplebar-track.simplebar-horizontal .simplebar-scrollbar:before {
+  height: 100%;
+  left: 2px;
+  right: 2px;
+}
+
+.simplebar-track.simplebar-horizontal .simplebar-scrollbar {
+  right: auto;
+  left: 0;
+  top: 2px;
+  height: 7px;
+  min-height: 0;
+  min-width: 10px;
+  width: auto;
+}
+
+/* Rtl support */
+[data-simplebar-direction='rtl'] .simplebar-track.simplebar-vertical {
+  right: auto;
+  left: 0;
+}
+
+.hs-dummy-scrollbar-size {
+  direction: rtl;
+  position: fixed;
+  opacity: 0;
+  visibility: hidden;
+  height: 500px;
+  width: 500px;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}

public/njum/css/sticky.css

@@ -0,0 +1,22 @@
+.sticky-container__video {
+  height: 270px;
+  width: 480px;
+  right: 0;
+  bottom: 0;
+  position: fixed;
+}
+.sticky-container_in-content .sticky-container__video {
+  padding-bottom: 56.25%;
+  position: relative;
+  height: 0; width: auto;
+  position: relative;
+  bottom: auto; right: auto;
+  overflow: hidden;
+}
+.sticky-container_in-content .sticky-container__video .sticky-container__object {
+  position: absolute;
+  top:0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+}

public/njum/js/floatvid.js

@@ -0,0 +1,17 @@
+var $window = $(window);
+var $videoWrap = $('.video-wrap');
+var $video = $('.video');
+var videoHeight = $video.outerHeight();
+
+$window.on('scroll',  function() {
+  var windowScrollTop = $window.scrollTop();
+  var videoBottom = videoHeight + $videoWrap.offset().top;
+  
+  if (windowScrollTop > videoBottom) {
+    $videoWrap.height(videoHeight);
+    $video.addClass('stuck');
+  } else {
+    $videoWrap.height('auto');
+    $video.removeClass('stuck');
+  }
+});

public/njum/js/floatvids.js

@@ -0,0 +1,257 @@
+//var $window = $(window);
+//var $videoWrap = $('.video-wrap');
+//var $video = $('.video');
+//var videoHeight = $video.outerHeight();
+//
+//$window.on('scroll',  function() {
+//  var windowScrollTop = $window.scrollTop();
+//  var videoBottom = videoHeight + $videoWrap.offset().top;
+//  
+//  if (windowScrollTop > videoBottom) {
+//    $videoWrap.height(videoHeight);
+//    $video.addClass('stuck');
+//  } else {
+//    $videoWrap.height('auto');
+//    $video.removeClass('stuck');
+//  }
+//});
+
+var ytIframeList, videoList, currentPlayer, closeButton, gradientOverlay, fullScreenIcon;
+var inViewPortBol = true;
+var ytIframeIdList = [];
+var ytVideoId = [];
+var ytPlayerId = [];
+var videoTagId = [];
+var events = new Array("pause", "playing");
+
+document.addEventListener('DOMContentLoaded', function () {
+
+    /*Adding Youtube Iframe API to body*/
+
+
+    /*Getting all the iframe from the Page and finding out valid URL and ID. Then creating instance of players*/
+
+
+
+    /*Getting Video Tag List and Creating instances*/
+
+    videoList = document.getElementsByTagName("video");
+    for (i = 0; i < videoList.length; i++) {
+        videoList[i].id = "video-wrap" + i;
+        videoTagId.push("video" + i);
+        videoTagId[i] = document.getElementById(videoList[i].id);
+
+    }
+    for (i = 0; i < videoTagId.length; i++) {
+        for (var j in events) {
+            videoTagId[i].addEventListener(events[j], videoTagPlayerhandler, false);
+        }
+    }
+
+
+
+});
+
+window.onYouTubeIframeAPIReady = function () {
+    for (i = 0; i < ytIframeIdList.length; i++) {
+        ytPlayerId[i] = new YT.Player(ytIframeList[i].id, {
+            events: {
+                "onStateChange": onPlayerStateChange
+            }
+        });
+    }
+};
+
+function videoTagPlayerhandler(e) {
+    /*Play Rules*/
+    for (i = 0; i < videoTagId.length; i++) {
+        if (e.target == videoTagId[i]) {
+            if (e.type == "playing") {
+                currentPlayer = videoTagId[i];
+                videoTagId[i].classList.remove("is-paused");
+                videoTagId[i].classList.add("is-playing");
+                break;
+            }
+        }
+    }
+    for (i = 0; i < videoTagId.length; i++) {
+        if (currentPlayer == videoTagId[i]) {
+            continue;
+        }
+        videoTagId[i].classList.remove("is-playing");
+        videoTagId[i].classList.add("is-paused");
+    }
+
+    /*Pause Rules*/
+    for (i = 0; i < videoTagId.length; i++) {
+        if (e.target == videoTagId[i]) {
+            if (e.type == "pause") {
+                videoTagId[i].classList.add("is-paused");
+                videoTagId[i].classList.remove("is-playing");
+                videoTagId[i].pause();
+            }
+        }
+    }
+
+    /*Sticky Rules*/
+    for (i = 0; i < videoTagId.length; i++) {
+        if (videoTagId[i].classList.contains("is-sticky")) {
+            videoTagId[i].pause();
+        }
+    }
+
+    for (i = 0; i < ytPlayerId.length; i++) {
+        if (ytVideoId[i].classList.contains("is-sticky")) {
+            ytPlayerId[i].pauseVideo();
+            fullScreenIcon.style.display = "none";
+
+        }
+    }
+
+    /*End Rules*/
+    for (i = 0; i < videoTagId.length; i++) {
+        if (e.target == videoTagId[i]) {
+            if (e.type == "ended") {
+                videoTagId[i].classList.remove("is-playing");
+                videoTagId[i].classList.remove("is-paused");
+            }
+        }
+    }
+    videohandler();
+};
+
+function onPlayerStateChange(event) {
+
+    /*Play Rules*/
+
+    for (i = 0; i < ytPlayerId.length; i++) {
+        if (ytPlayerId[i].getPlayerState() === 1) {
+            currentPlayer = ytVideoId[i];
+            ytVideoId[i].classList.remove("is-paused");
+            ytVideoId[i].classList.add("is-playing");
+            break;
+        }
+    }
+    for (i = 0; i < ytVideoId.length; i++) {
+        if (currentPlayer == ytVideoId[i]) {
+            continue;
+        }
+        ytVideoId[i].classList.remove("is-playing");
+        ytVideoId[i].classList.add("is-paused");
+    }
+
+    /*Pause Rules*/
+
+    for (i = 0; i < ytPlayerId.length; i++) {
+        if (ytPlayerId[i].getPlayerState() === 2) {
+            ytVideoId[i].classList.add("is-paused");
+            ytVideoId[i].classList.remove("is-playing");
+            ytPlayerId[i].pauseVideo();
+        }
+    }
+
+
+    /*Sticky Rules*/
+
+    for (i = 0; i < ytPlayerId.length; i++) {
+        if (ytVideoId[i].classList.contains("is-sticky")) {
+            ytPlayerId[i].pauseVideo();
+            fullScreenIcon.style.display = "none";
+
+        }
+    }
+
+    for (i = 0; i < videoTagId.length; i++) {
+        if (videoTagId[i].classList.contains("is-sticky")) {
+            videoTagId[i].pause();
+            fullScreenIcon.style.display = "none";
+
+        }
+    }
+
+    /*End Rule*/
+
+    for (i = 0; i < ytPlayerId.length; i++) {
+        if (ytPlayerId[i].getPlayerState() === 0) {
+            ytVideoId[i].classList.remove("is-playing");
+            ytVideoId[i].classList.remove("is-paused");
+        }
+    }
+    videohandler();
+}
+
+function videohandler() {
+
+    if (currentPlayer) {
+        if (closeButton) {
+            closeButton.addEventListener("click", function (e) {
+                if (currentPlayer.classList.contains("is-sticky")) {
+                    currentPlayer.classList.remove("is-sticky");
+
+                    for (i = 0; i < ytVideoId.length; i++) {
+                        if (currentPlayer == ytVideoId[i]) {
+                            ytPlayerId[i].pauseVideo();
+                        }
+                    }
+                    for (i = 0; i < videoTagId.length; i++) {
+                        if (currentPlayer == videoTagId[i]) {
+                            videoTagId[i].pause();
+                        }
+                    }
+
+                } else {
+                    for (i = 0; i < ytVideoId.length; i++) {
+                        if (currentPlayer != ytVideoId[i]) {
+                            ytVideoId[i].classList.remove("is-sticky");
+                        }
+                    }
+                    for (i = 0; i < videoTagId.length; i++) {
+                        if (currentPlayer != videoTagId[i]) {
+                            videoTagId[i].classList.remove("is-sticky");
+                        }
+                    }
+                }
+
+            });
+        }
+    }
+}
+
+window.addEventListener('scroll', function () {
+
+    inViewPortBol = inViewPort();
+    if (currentPlayer) {
+        if (!inViewPortBol && currentPlayer.classList.contains("is-playing")) {
+            for (i = 0; i < ytVideoId.length; i++) {
+                if (currentPlayer != ytVideoId[i]) {
+                    ytVideoId[i].classList.remove("is-sticky");
+                }
+            }
+            for (i = 0; i < videoTagId.length; i++) {
+                if (currentPlayer != videoTagId[i]) {
+                    videoTagId[i].classList.remove("is-sticky");
+                }
+            }
+            currentPlayer.classList.add("is-sticky");
+        } else {
+            if (currentPlayer.classList.contains("is-sticky")) {
+                currentPlayer.classList.remove("is-sticky");
+            }
+        }
+    }
+});
+
+
+
+
+function inViewPort() {
+
+    if (currentPlayer) {
+        var videoParentLocal = currentPlayer.parentElement.getBoundingClientRect();
+        return videoParentLocal.bottom > 0 &&
+            videoParentLocal.right > 0 &&
+            videoParentLocal.left < (window.innerWidth || document.documentElement.clientWidth) &&
+            videoParentLocal.top < (window.innerHeight || document.documentElement.clientHeight);
+    }
+}
+

public/njum/js/jquery.timeago.js

@@ -0,0 +1,225 @@
+/**
+ * Timeago is a jQuery plugin that makes it easy to support automatically
+ * updating fuzzy timestamps (e.g. "4 minutes ago" or "about 1 day ago").
+ *
+ * @name timeago
+ * @version 1.5.2
+ * @requires jQuery v1.2.3+
+ * @author Ryan McGeary
+ * @license MIT License - http://www.opensource.org/licenses/mit-license.php
+ *
+ * For usage and examples, visit:
+ * http://timeago.yarp.com/
+ *
+ * Copyright (c) 2008-2015, Ryan McGeary (ryan -[at]- mcgeary [*dot*] org)
+ */
+
+(function (factory) {
+  if (typeof define === 'function' && define.amd) {
+    // AMD. Register as an anonymous module.
+    define(['jquery'], factory);
+  } else if (typeof module === 'object' && typeof module.exports === 'object') {
+    factory(require('jquery'));
+  } else {
+    // Browser globals
+    factory(jQuery);
+  }
+}(function ($) {
+  $.timeago = function(timestamp) {
+    if (timestamp instanceof Date) {
+      return inWords(timestamp);
+    } else if (typeof timestamp === "string") {
+      return inWords($.timeago.parse(timestamp));
+    } else if (typeof timestamp === "number") {
+      return inWords(new Date(timestamp));
+    } else {
+      return inWords($.timeago.datetime(timestamp));
+    }
+  };
+  var $t = $.timeago;
+
+  $.extend($.timeago, {
+    settings: {
+      refreshMillis: 60000,
+      allowPast: true,
+      allowFuture: false,
+      localeTitle: false,
+      cutoff: 0,
+      autoDispose: true,
+      strings: {
+        prefixAgo: null,
+        prefixFromNow: null,
+        suffixAgo: "ago",
+        suffixFromNow: "from now",
+        inPast: 'any moment now',
+        seconds: "less than a minute",
+        minute: "about a minute",
+        minutes: "%d minutes",
+        hour: "about an hour",
+        hours: "about %d hours",
+        day: "a day",
+        days: "%d days",
+        month: "about a month",
+        months: "%d months",
+        year: "about a year",
+        years: "%d years",
+        wordSeparator: " ",
+        numbers: []
+      }
+    },
+
+    inWords: function(distanceMillis) {
+      if (!this.settings.allowPast && ! this.settings.allowFuture) {
+          throw 'timeago allowPast and allowFuture settings can not both be set to false.';
+      }
+
+      var $l = this.settings.strings;
+      var prefix = $l.prefixAgo;
+      var suffix = $l.suffixAgo;
+      if (this.settings.allowFuture) {
+        if (distanceMillis < 0) {
+          prefix = $l.prefixFromNow;
+          suffix = $l.suffixFromNow;
+        }
+      }
+
+      if (!this.settings.allowPast && distanceMillis >= 0) {
+        return this.settings.strings.inPast;
+      }
+
+      var seconds = Math.abs(distanceMillis) / 1000;
+      var minutes = seconds / 60;
+      var hours = minutes / 60;
+      var days = hours / 24;
+      var years = days / 365;
+
+      function substitute(stringOrFunction, number) {
+        var string = $.isFunction(stringOrFunction) ? stringOrFunction(number, distanceMillis) : stringOrFunction;
+        var value = ($l.numbers && $l.numbers[number]) || number;
+        return string.replace(/%d/i, value);
+      }
+
+      var words = seconds < 45 && substitute($l.seconds, Math.round(seconds)) ||
+        seconds < 90 && substitute($l.minute, 1) ||
+        minutes < 45 && substitute($l.minutes, Math.round(minutes)) ||
+        minutes < 90 && substitute($l.hour, 1) ||
+        hours < 24 && substitute($l.hours, Math.round(hours)) ||
+        hours < 42 && substitute($l.day, 1) ||
+        days < 30 && substitute($l.days, Math.round(days)) ||
+        days < 45 && substitute($l.month, 1) ||
+        days < 365 && substitute($l.months, Math.round(days / 30)) ||
+        years < 1.5 && substitute($l.year, 1) ||
+        substitute($l.years, Math.round(years));
+
+      var separator = $l.wordSeparator || "";
+      if ($l.wordSeparator === undefined) { separator = " "; }
+      return $.trim([prefix, words, suffix].join(separator));
+    },
+
+    parse: function(iso8601) {
+      var s = $.trim(iso8601);
+      s = s.replace(/\.\d+/,""); // remove milliseconds
+      s = s.replace(/-/,"/").replace(/-/,"/");
+      s = s.replace(/T/," ").replace(/Z/," UTC");
+      s = s.replace(/([\+\-]\d\d)\:?(\d\d)/," $1$2"); // -04:00 -> -0400
+      s = s.replace(/([\+\-]\d\d)$/," $100"); // +09 -> +0900
+      return new Date(s);
+    },
+    datetime: function(elem) {
+      var iso8601 = $t.isTime(elem) ? $(elem).attr("datetime") : $(elem).attr("title");
+      return $t.parse(iso8601);
+    },
+    isTime: function(elem) {
+      // jQuery's `is()` doesn't play well with HTML5 in IE
+      return $(elem).get(0).tagName.toLowerCase() === "time"; // $(elem).is("time");
+    }
+  });
+
+  // functions that can be called via $(el).timeago('action')
+  // init is default when no action is given
+  // functions are called with context of a single element
+  var functions = {
+    init: function() {
+      var refresh_el = $.proxy(refresh, this);
+      refresh_el();
+      var $s = $t.settings;
+      if ($s.refreshMillis > 0) {
+        this._timeagoInterval = setInterval(refresh_el, $s.refreshMillis);
+      }
+    },
+    update: function(timestamp) {
+      var date = (timestamp instanceof Date) ? timestamp : $t.parse(timestamp);
+      $(this).data('timeago', { datetime: date });
+      if ($t.settings.localeTitle) $(this).attr("title", date.toLocaleString());
+      refresh.apply(this);
+    },
+    updateFromDOM: function() {
+      $(this).data('timeago', { datetime: $t.parse( $t.isTime(this) ? $(this).attr("datetime") : $(this).attr("title") ) });
+      refresh.apply(this);
+    },
+    dispose: function () {
+      if (this._timeagoInterval) {
+        window.clearInterval(this._timeagoInterval);
+        this._timeagoInterval = null;
+      }
+    }
+  };
+
+  $.fn.timeago = function(action, options) {
+    var fn = action ? functions[action] : functions.init;
+    if (!fn) {
+      throw new Error("Unknown function name '"+ action +"' for timeago");
+    }
+    // each over objects here and call the requested function
+    this.each(function() {
+      fn.call(this, options);
+    });
+    return this;
+  };
+
+  function refresh() {
+    var $s = $t.settings;
+
+    //check if it's still visible
+    if ($s.autoDispose && !$.contains(document.documentElement,this)) {
+      //stop if it has been removed
+      $(this).timeago("dispose");
+      return this;
+    }
+
+    var data = prepareData(this);
+
+    if (!isNaN(data.datetime)) {
+      if ( $s.cutoff == 0 || Math.abs(distance(data.datetime)) < $s.cutoff) {
+        $(this).text(inWords(data.datetime));
+      }
+    }
+    return this;
+  }
+
+  function prepareData(element) {
+    element = $(element);
+    if (!element.data("timeago")) {
+      element.data("timeago", { datetime: $t.datetime(element) });
+      var text = $.trim(element.text());
+      if ($t.settings.localeTitle) {
+        element.attr("title", element.data('timeago').datetime.toLocaleString());
+      } else if (text.length > 0 && !($t.isTime(element) && element.attr("title"))) {
+        element.attr("title", text);
+      }
+    }
+    return element.data("timeago");
+  }
+
+  function inWords(date) {
+    return $t.inWords(distance(date));
+  }
+
+  function distance(date) {
+    return (new Date().getTime() - date.getTime());
+  }
+
+  // fix for IE6 suckage
+  document.createElement("abbr");
+  document.createElement("time");
+}));

public/njum/js/sticky_video.js

@@ -0,0 +1,100 @@
+(function (global) {
+  'use strict'
+
+  var StickyVideo = function (containerId) {
+    this.containerId = containerId || 'sticky-container'
+    this.container = document.getElementById(this.containerId)
+    this.initialize()
+  }
+
+  StickyVideo.addClass = addClass
+  StickyVideo.removeClass = removeClass
+  StickyVideo.hasClass = hasClass
+  StickyVideo.wrap = wrap
+  StickyVideo.insertAfter = insertAfter
+
+  StickyVideo.prototype.fixElementHeight = fixElementHeight
+  StickyVideo.prototype.elementInViewport = elementInViewport
+  StickyVideo.prototype.initialize = initialize
+
+  function fixElementHeight () {
+    this.container.parentElement.style.height = this.container.parentElement.offsetHeight + 'px'
+  }
+  function addClass (elements, className) {
+    if (hasClass(elements, className)) return
+    if (!elements) { return }
+    if (typeof elements === 'string') {
+      elements = document.querySelectorAll(elements)
+    } else if (elements.tagName) { elements = [elements] }
+    for (var i = 0; i < elements.length; i++) {
+      if ((' ' + elements[i].className + ' ').indexOf(' ' + className + ' ') < 0) {
+        elements[i].className += ' ' + className
+      }
+    }
+  }
+  function removeClass (elements, className) {
+    if (!hasClass(elements, className)) return
+    if (!elements) { return }
+    if (typeof elements === 'string') {
+      elements = document.querySelectorAll(elements)
+    } else if (elements.tagName) { elements = [elements] }
+    var reg = new RegExp('(^| )' + className + '($| )', 'g')
+    for (var i = 0; i < elements.length; i++) {
+      elements[i].className = elements[i].className.replace(reg, '')
+    }
+  }
+  function hasClass (element, className) {
+    return new RegExp('(\\s|^)' + className + '(\\s|$)').test(element.className)
+  }
+  function wrap (toWrap, wrapper) {
+    return wrapper.appendChild(toWrap)
+  }
+  function insertAfter (el, referenceNode) {
+    referenceNode.parentNode.insertBefore(el, referenceNode.nextSibling)
+  }
+  function elementInViewport (el) {
+    var rect = el.getBoundingClientRect()
+    return (rect.top > (el.offsetHeight * -1))
+  }
+  function initialize () {
+    if (!this.container) return
+    var that = this
+    var wrapDiv = document.createElement('div')
+
+    function onWindowScroll () {
+      that.fixElementHeight()
+      var parent = wrapDiv
+      if (!that.elementInViewport(parent)) {
+        StickyVideo.removeClass(parent, 'sticky-container_in-content')
+        StickyVideo.addClass(parent, 'sticky-container_sticky')
+      } else {
+        StickyVideo.removeClass(parent, 'sticky-container_sticky')
+        StickyVideo.addClass(parent, 'sticky-container_in-content')
+      }
+    }
+
+    wrapDiv.className = 'sticky-container__wrap'
+    this.container.parentElement.insertBefore(wrapDiv, this.container)
+    StickyVideo.insertAfter(wrapDiv, that.container)
+    StickyVideo.wrap(that.container, wrapDiv)
+    StickyVideo.addClass(wrapDiv, 'sticky-container_in-content')
+    StickyVideo.addClass(that.container, 'sticky-container__video')
+
+    window.addEventListener ? window.addEventListener('scroll', onWindowScroll) : window.onscroll = onWindowScroll
+  }
+
+  // AMD support
+  if (typeof define === 'function' && define.amd) {
+    define(function () { return StickyVideo })
+    // CommonJS and Node.js module support.
+  } else if (typeof exports !== 'undefined') {
+    // Support Node.js specific `module.exports` (which can be a function)
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = StickyVideo
+    }
+    // But always support CommonJS module 1.1.1 spec (`exports` cannot be a function)
+    exports.StickyVideo = StickyVideo
+  } else {
+    global.StickyVideo = StickyVideo
+  }
+})(this)