/* Minification failed. Returning unminified contents.
(896,84-85): run-time error JS1195: Expected expression: >
(898,14-15): run-time error JS1195: Expected expression: )
 */
/*!
Waypoints - 4.0.0
Copyright © 2011-2015 Caleb Troughton
Licensed under the MIT license.
https://github.com/imakewebthings/waypoints/blog/master/licenses.txt
*/
(function() {
  'use strict'

  var keyCounter = 0
  var allWaypoints = {}

  /* http://imakewebthings.com/waypoints/api/waypoint */
  function Waypoint(options) {
    if (!options) {
      throw new Error('No options passed to Waypoint constructor')
    }
    if (!options.element) {
      throw new Error('No element option passed to Waypoint constructor')
    }
    if (!options.handler) {
      throw new Error('No handler option passed to Waypoint constructor')
    }

    this.key = 'waypoint-' + keyCounter
    this.options = Waypoint.Adapter.extend({}, Waypoint.defaults, options)
    this.element = this.options.element
    this.adapter = new Waypoint.Adapter(this.element)
    this.callback = options.handler
    this.axis = this.options.horizontal ? 'horizontal' : 'vertical'
    this.enabled = this.options.enabled
    this.triggerPoint = null
    this.group = Waypoint.Group.findOrCreate({
      name: this.options.group,
      axis: this.axis
    })
    this.context = Waypoint.Context.findOrCreateByElement(this.options.context)

    if (Waypoint.offsetAliases[this.options.offset]) {
      this.options.offset = Waypoint.offsetAliases[this.options.offset]
    }
    this.group.add(this)
    this.context.add(this)
    allWaypoints[this.key] = this
    keyCounter += 1
  }

  /* Private */
  Waypoint.prototype.queueTrigger = function(direction) {
    this.group.queueTrigger(this, direction)
  }

  /* Private */
  Waypoint.prototype.trigger = function(args) {
    if (!this.enabled) {
      return
    }
    if (this.callback) {
      this.callback.apply(this, args)
    }
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/destroy */
  Waypoint.prototype.destroy = function() {
    this.context.remove(this)
    this.group.remove(this)
    delete allWaypoints[this.key]
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/disable */
  Waypoint.prototype.disable = function() {
    this.enabled = false
    return this
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/enable */
  Waypoint.prototype.enable = function() {
    this.context.refresh()
    this.enabled = true
    return this
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/next */
  Waypoint.prototype.next = function() {
    return this.group.next(this)
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/previous */
  Waypoint.prototype.previous = function() {
    return this.group.previous(this)
  }

  /* Private */
  Waypoint.invokeAll = function(method) {
    var allWaypointsArray = []
    for (var waypointKey in allWaypoints) {
      allWaypointsArray.push(allWaypoints[waypointKey])
    }
    for (var i = 0, end = allWaypointsArray.length; i < end; i++) {
      allWaypointsArray[i][method]()
    }
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/destroy-all */
  Waypoint.destroyAll = function() {
    Waypoint.invokeAll('destroy')
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/disable-all */
  Waypoint.disableAll = function() {
    Waypoint.invokeAll('disable')
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/enable-all */
  Waypoint.enableAll = function() {
    Waypoint.invokeAll('enable')
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/refresh-all */
  Waypoint.refreshAll = function() {
    Waypoint.Context.refreshAll()
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/viewport-height */
  Waypoint.viewportHeight = function() {
    return window.innerHeight || document.documentElement.clientHeight
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/viewport-width */
  Waypoint.viewportWidth = function() {
    return document.documentElement.clientWidth
  }

  Waypoint.adapters = []

  Waypoint.defaults = {
    context: window,
    continuous: true,
    enabled: true,
    group: 'default',
    horizontal: false,
    offset: 0
  }

  Waypoint.offsetAliases = {
    'bottom-in-view': function() {
      return this.context.innerHeight() - this.adapter.outerHeight()
    },
    'right-in-view': function() {
      return this.context.innerWidth() - this.adapter.outerWidth()
    }
  }

  window.Waypoint = Waypoint
}())
;(function() {
  'use strict'

  function requestAnimationFrameShim(callback) {
    window.setTimeout(callback, 1000 / 60)
  }

  var keyCounter = 0
  var contexts = {}
  var Waypoint = window.Waypoint
  var oldWindowLoad = window.onload

  /* http://imakewebthings.com/waypoints/api/context */
  function Context(element) {
    this.element = element
    this.Adapter = Waypoint.Adapter
    this.adapter = new this.Adapter(element)
    this.key = 'waypoint-context-' + keyCounter
    this.didScroll = false
    this.didResize = false
    this.oldScroll = {
      x: this.adapter.scrollLeft(),
      y: this.adapter.scrollTop()
    }
    this.waypoints = {
      vertical: {},
      horizontal: {}
    }

    element.waypointContextKey = this.key
    contexts[element.waypointContextKey] = this
    keyCounter += 1

    this.createThrottledScrollHandler()
    this.createThrottledResizeHandler()
  }

  /* Private */
  Context.prototype.add = function(waypoint) {
    var axis = waypoint.options.horizontal ? 'horizontal' : 'vertical'
    this.waypoints[axis][waypoint.key] = waypoint
    this.refresh()
  }

  /* Private */
  Context.prototype.checkEmpty = function() {
    var horizontalEmpty = this.Adapter.isEmptyObject(this.waypoints.horizontal)
    var verticalEmpty = this.Adapter.isEmptyObject(this.waypoints.vertical)
    if (horizontalEmpty && verticalEmpty) {
      this.adapter.off('.waypoints')
      delete contexts[this.key]
    }
  }

  /* Private */
  Context.prototype.createThrottledResizeHandler = function() {
    var self = this

    function resizeHandler() {
      self.handleResize()
      self.didResize = false
    }

    this.adapter.on('resize.waypoints', function() {
      if (!self.didResize) {
        self.didResize = true
        Waypoint.requestAnimationFrame(resizeHandler)
      }
    })
  }

  /* Private */
  Context.prototype.createThrottledScrollHandler = function() {
    var self = this
    function scrollHandler() {
      self.handleScroll()
      self.didScroll = false
    }

    this.adapter.on('scroll.waypoints', function() {
      if (!self.didScroll || Waypoint.isTouch) {
        self.didScroll = true
        Waypoint.requestAnimationFrame(scrollHandler)
      }
    })
  }

  /* Private */
  Context.prototype.handleResize = function() {
    Waypoint.Context.refreshAll()
  }

  /* Private */
  Context.prototype.handleScroll = function() {
    var triggeredGroups = {}
    var axes = {
      horizontal: {
        newScroll: this.adapter.scrollLeft(),
        oldScroll: this.oldScroll.x,
        forward: 'right',
        backward: 'left'
      },
      vertical: {
        newScroll: this.adapter.scrollTop(),
        oldScroll: this.oldScroll.y,
        forward: 'down',
        backward: 'up'
      }
    }

    for (var axisKey in axes) {
      var axis = axes[axisKey]
      var isForward = axis.newScroll > axis.oldScroll
      var direction = isForward ? axis.forward : axis.backward

      for (var waypointKey in this.waypoints[axisKey]) {
        var waypoint = this.waypoints[axisKey][waypointKey]
        var wasBeforeTriggerPoint = axis.oldScroll < waypoint.triggerPoint
        var nowAfterTriggerPoint = axis.newScroll >= waypoint.triggerPoint
        var crossedForward = wasBeforeTriggerPoint && nowAfterTriggerPoint
        var crossedBackward = !wasBeforeTriggerPoint && !nowAfterTriggerPoint
        if (crossedForward || crossedBackward) {
          waypoint.queueTrigger(direction)
          triggeredGroups[waypoint.group.id] = waypoint.group
        }
      }
    }

    for (var groupKey in triggeredGroups) {
      triggeredGroups[groupKey].flushTriggers()
    }

    this.oldScroll = {
      x: axes.horizontal.newScroll,
      y: axes.vertical.newScroll
    }
  }

  /* Private */
  Context.prototype.innerHeight = function() {
    /*eslint-disable eqeqeq */
    if (this.element == this.element.window) {
      return Waypoint.viewportHeight()
    }
    /*eslint-enable eqeqeq */
    return this.adapter.innerHeight()
  }

  /* Private */
  Context.prototype.remove = function(waypoint) {
    delete this.waypoints[waypoint.axis][waypoint.key]
    this.checkEmpty()
  }

  /* Private */
  Context.prototype.innerWidth = function() {
    /*eslint-disable eqeqeq */
    if (this.element == this.element.window) {
      return Waypoint.viewportWidth()
    }
    /*eslint-enable eqeqeq */
    return this.adapter.innerWidth()
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-destroy */
  Context.prototype.destroy = function() {
    var allWaypoints = []
    for (var axis in this.waypoints) {
      for (var waypointKey in this.waypoints[axis]) {
        allWaypoints.push(this.waypoints[axis][waypointKey])
      }
    }
    for (var i = 0, end = allWaypoints.length; i < end; i++) {
      allWaypoints[i].destroy()
    }
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-refresh */
  Context.prototype.refresh = function() {
    /*eslint-disable eqeqeq */
    var isWindow = this.element == this.element.window
    /*eslint-enable eqeqeq */
    var contextOffset = isWindow ? undefined : this.adapter.offset()
    var triggeredGroups = {}
    var axes

    this.handleScroll()
    axes = {
      horizontal: {
        contextOffset: isWindow ? 0 : contextOffset.left,
        contextScroll: isWindow ? 0 : this.oldScroll.x,
        contextDimension: this.innerWidth(),
        oldScroll: this.oldScroll.x,
        forward: 'right',
        backward: 'left',
        offsetProp: 'left'
      },
      vertical: {
        contextOffset: isWindow ? 0 : contextOffset.top,
        contextScroll: isWindow ? 0 : this.oldScroll.y,
        contextDimension: this.innerHeight(),
        oldScroll: this.oldScroll.y,
        forward: 'down',
        backward: 'up',
        offsetProp: 'top'
      }
    }

    for (var axisKey in axes) {
      var axis = axes[axisKey]
      for (var waypointKey in this.waypoints[axisKey]) {
        var waypoint = this.waypoints[axisKey][waypointKey]
        var adjustment = waypoint.options.offset
        var oldTriggerPoint = waypoint.triggerPoint
        var elementOffset = 0
        var freshWaypoint = oldTriggerPoint == null
        var contextModifier, wasBeforeScroll, nowAfterScroll
        var triggeredBackward, triggeredForward

        if (waypoint.element !== waypoint.element.window) {
          elementOffset = waypoint.adapter.offset()[axis.offsetProp]
        }

        if (typeof adjustment === 'function') {
          adjustment = adjustment.apply(waypoint)
        }
        else if (typeof adjustment === 'string') {
          adjustment = parseFloat(adjustment)
          if (waypoint.options.offset.indexOf('%') > - 1) {
            adjustment = Math.ceil(axis.contextDimension * adjustment / 100)
          }
        }

        contextModifier = axis.contextScroll - axis.contextOffset
        waypoint.triggerPoint = elementOffset + contextModifier - adjustment
        wasBeforeScroll = oldTriggerPoint < axis.oldScroll
        nowAfterScroll = waypoint.triggerPoint >= axis.oldScroll
        triggeredBackward = wasBeforeScroll && nowAfterScroll
        triggeredForward = !wasBeforeScroll && !nowAfterScroll

        if (!freshWaypoint && triggeredBackward) {
          waypoint.queueTrigger(axis.backward)
          triggeredGroups[waypoint.group.id] = waypoint.group
        }
        else if (!freshWaypoint && triggeredForward) {
          waypoint.queueTrigger(axis.forward)
          triggeredGroups[waypoint.group.id] = waypoint.group
        }
        else if (freshWaypoint && axis.oldScroll >= waypoint.triggerPoint) {
          waypoint.queueTrigger(axis.forward)
          triggeredGroups[waypoint.group.id] = waypoint.group
        }
      }
    }

    Waypoint.requestAnimationFrame(function() {
      for (var groupKey in triggeredGroups) {
        triggeredGroups[groupKey].flushTriggers()
      }
    })

    return this
  }

  /* Private */
  Context.findOrCreateByElement = function(element) {
    return Context.findByElement(element) || new Context(element)
  }

  /* Private */
  Context.refreshAll = function() {
    for (var contextId in contexts) {
      contexts[contextId].refresh()
    }
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/context-find-by-element */
  Context.findByElement = function(element) {
    return contexts[element.waypointContextKey]
  }

  window.onload = function() {
    if (oldWindowLoad) {
      oldWindowLoad()
    }
    Context.refreshAll()
  }

  Waypoint.requestAnimationFrame = function(callback) {
    var requestFn = window.requestAnimationFrame ||
      window.mozRequestAnimationFrame ||
      window.webkitRequestAnimationFrame ||
      requestAnimationFrameShim
    requestFn.call(window, callback)
  }
  Waypoint.Context = Context
}())
;(function() {
  'use strict'

  function byTriggerPoint(a, b) {
    return a.triggerPoint - b.triggerPoint
  }

  function byReverseTriggerPoint(a, b) {
    return b.triggerPoint - a.triggerPoint
  }

  var groups = {
    vertical: {},
    horizontal: {}
  }
  var Waypoint = window.Waypoint

  /* http://imakewebthings.com/waypoints/api/group */
  function Group(options) {
    this.name = options.name
    this.axis = options.axis
    this.id = this.name + '-' + this.axis
    this.waypoints = []
    this.clearTriggerQueues()
    groups[this.axis][this.name] = this
  }

  /* Private */
  Group.prototype.add = function(waypoint) {
    this.waypoints.push(waypoint)
  }

  /* Private */
  Group.prototype.clearTriggerQueues = function() {
    this.triggerQueues = {
      up: [],
      down: [],
      left: [],
      right: []
    }
  }

  /* Private */
  Group.prototype.flushTriggers = function() {
    for (var direction in this.triggerQueues) {
      var waypoints = this.triggerQueues[direction]
      var reverse = direction === 'up' || direction === 'left'
      waypoints.sort(reverse ? byReverseTriggerPoint : byTriggerPoint)
      for (var i = 0, end = waypoints.length; i < end; i += 1) {
        var waypoint = waypoints[i]
        if (waypoint.options.continuous || i === waypoints.length - 1) {
          waypoint.trigger([direction])
        }
      }
    }
    this.clearTriggerQueues()
  }

  /* Private */
  Group.prototype.next = function(waypoint) {
    this.waypoints.sort(byTriggerPoint)
    var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
    var isLast = index === this.waypoints.length - 1
    return isLast ? null : this.waypoints[index + 1]
  }

  /* Private */
  Group.prototype.previous = function(waypoint) {
    this.waypoints.sort(byTriggerPoint)
    var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
    return index ? this.waypoints[index - 1] : null
  }

  /* Private */
  Group.prototype.queueTrigger = function(waypoint, direction) {
    this.triggerQueues[direction].push(waypoint)
  }

  /* Private */
  Group.prototype.remove = function(waypoint) {
    var index = Waypoint.Adapter.inArray(waypoint, this.waypoints)
    if (index > -1) {
      this.waypoints.splice(index, 1)
    }
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/first */
  Group.prototype.first = function() {
    return this.waypoints[0]
  }

  /* Public */
  /* http://imakewebthings.com/waypoints/api/last */
  Group.prototype.last = function() {
    return this.waypoints[this.waypoints.length - 1]
  }

  /* Private */
  Group.findOrCreate = function(options) {
    return groups[options.axis][options.name] || new Group(options)
  }

  Waypoint.Group = Group
}())
;(function() {
  'use strict'

  var $ = window.jQuery
  var Waypoint = window.Waypoint

  function JQueryAdapter(element) {
    this.$element = $(element)
  }

  $.each([
    'innerHeight',
    'innerWidth',
    'off',
    'offset',
    'on',
    'outerHeight',
    'outerWidth',
    'scrollLeft',
    'scrollTop'
  ], function(i, method) {
    JQueryAdapter.prototype[method] = function() {
      var args = Array.prototype.slice.call(arguments)
      return this.$element[method].apply(this.$element, args)
    }
  })

  $.each([
    'extend',
    'inArray',
    'isEmptyObject'
  ], function(i, method) {
    JQueryAdapter[method] = $[method]
  })

  Waypoint.adapters.push({
    name: 'jquery',
    Adapter: JQueryAdapter
  })
  Waypoint.Adapter = JQueryAdapter
}())
;(function() {
  'use strict'

  var Waypoint = window.Waypoint

  function createExtension(framework) {
    return function() {
      var waypoints = []
      var overrides = arguments[0]

      if (framework.isFunction(arguments[0])) {
        overrides = framework.extend({}, arguments[1])
        overrides.handler = arguments[0]
      }

      this.each(function() {
        var options = framework.extend({}, overrides, {
          element: this
        })
        if (typeof options.context === 'string') {
          options.context = framework(this).closest(options.context)[0]
        }
        waypoints.push(new Waypoint(options))
      })

      return waypoints
    }
  }

  if (window.jQuery) {
    window.jQuery.fn.waypoint = createExtension(window.jQuery)
  }
  if (window.Zepto) {
    window.Zepto.fn.waypoint = createExtension(window.Zepto)
  }
}())
;;

function rightBarStickyNeeded() {
    return $(window).width() > 992;
}

function loadMorePosts(e) {
    e.stopImmediatePropagation();
    e.preventDefault;

    //Ignore loadmore while it is loading...
    if ($(this).attr('disabled') == 'disabled')
        return false;

    //removes focus from the button so it can append correctly
    $(this).blur();

    var $btn = $(this);
    var $postsList = $('.posts').last();//in case of multiple posts classs, use the last one on the page.
    var newPageUrl = $btn.attr('href');
    var pageNumber = $btn.data('pageNumber');
    var pageParam = $btn.data('pageParam');

    var getUrl = $btn.data('ajaxPath');
    if (!getUrl) {
        //when there's no getUrl it should clickthrough to href
        return true;
    }
    else {
        e.stopImmediatePropagation();
        e.preventDefault;

        $.ajax({
            type: 'GET',
            cache: false,
            url: getUrl,
            dataType: 'html',
            beforeSend: function () {
                $btn.attr('disabled', 'disabled');
                $btn.text('Loading...');
            },
            success: function (data) {
                if ($.trim(data) != '') {   //because we're getting back HTML, we have to make sure the result is NOT empty

                    //display new posts, rightbar section, and banner ad
                    $postsList.append(data);

                    findAndLoadDynamicAds(data);

                    makeLastRightBarSectionSticky();

                    //auto loadmore setup
                    var autoLoadMorePosts = $(".posts-load-more").waypoint(function (direction) {
                        if (direction == "down") {
                            $(this.element).trigger("click");
                        }
                        this.destroy(); //destroy since it will get recreated on next page load.
                    }, {
                        offset: $(window).height() + 100
                    });

                    // update load more button
                    var nextPageNumber = pageNumber + 1;
                    $btn.data('pageNumber', nextPageNumber);
                    $btn.data('pageParam', pageParam);
                    //var nextPageUrl = newPageUrl.replace('page=' + pageNumber, 'page=' + nextPageNumber);
                    var nextPageUrl = newPageUrl.replace(pageParam + '=' + pageNumber, pageParam + '=' + nextPageNumber);
                    $btn.attr('href', nextPageUrl);

                    var nextPageAjaxPath = getUrl.replace(pageParam + '=' + pageNumber, pageParam + '=' + nextPageNumber);
                    $btn.data('ajaxPath', nextPageAjaxPath);

                    // update banner ad goes here (maybe?)

                    observeLozad();

                // update page url
                if (history.pushState) {
                    //window.history.pushState({ page: pageNumber }, document.title, newPageUrl);
                    switch (pageParam) {
                        case 'page':
                            window.history.pushState({ page: pageNumber }, document.title, newPageUrl);
                            break;
                        case 'pagenum':
                            window.history.pushState({ pagenum: pageNumber }, document.title, newPageUrl);
                            break;
                    }
                }

                } else {
                    $btn.parent().hide(); // this hides the load more button when we have no more items to display
                }
            },
            error: function (jqXHR, textStatus, errorThrown) {
                //alert('jqXHR: ' + jqXHR + ', Status: ' + textStatus + ', Error: '+ errorThrown);
                //alert('There was an error loading more.');
            },
            complete: function () {
                $btn.removeAttr('disabled');
                $btn.text('Load More');
            }
        });
        return false;
    }
}

window.loadMorePostsFirstPage = function (pageUrl, loadingMessage) {
    var $container = $('#postlist-container').last();//in case of multiple posts classs, use the last one on the page.

    var getUrl = pageUrl;
    var loadingMsg = loadingMessage ? loadingMessage : 'Loading more stories...';

    $.ajax({
        type: 'GET',
        cache: false,
        url: getUrl,
        dataType: 'html',
        beforeSend: function () {
            $box = $("<div/>").addClass("loading p-14-gray text-center margin-bottom-10");
            $box.append($("<p/>").text(loadingMsg));
            $box.append($("<p/>").append($("<img/>").attr("src", "/content/img/spinner-1s-81px.gif")));
            $container.append($box);
        },
        success: function (data) {
            if ($.trim(data) != '') {   //because we're getting back HTML, we have to make sure the result is NOT empty

                //display new posts, rightbar section, and banner ad
                $container.append(data);

                findAndLoadDynamicAds(data);

                makeLastRightBarSectionSticky();

                observeLozad();

            }
        },
        error: function (jqXHR, textStatus, errorThrown) {
            //alert('jqXHR: ' + jqXHR + ', Status: ' + textStatus + ', Error: '+ errorThrown);
            //alert('There was an error loading more.');
        },
        complete: function () {
            $container.find(".loading").remove();
        }
    });
    return false;
};

window.loadContentOffers = function (pageUrl) {
    var $container = $('#contentoffers-container').last();

    var getUrl = pageUrl;

    $.ajax({
        type: 'GET',
        cache: false,
        url: getUrl,
        dataType: 'html',
        beforeSend: function () {
            $box = $("<div/>").addClass("loading p-14-gray text-center margin-bottom-10");
            $box.append($("<p/>").text("Loading related content..."));
            $box.append($("<p/>").append($("<img/>").attr("src", "/content/img/spinner-1s-81px.gif")));
            $container.append($box);
        },
        success: function (data) {
            if ($.trim(data) != '') {   //because we're getting back HTML, we have to make sure the result is NOT empty

                //display new posts, rightbar section, and banner ad
                $container.append(data);

                observeLozad();

            }
        },
        error: function (jqXHR, textStatus, errorThrown) {
            //alert('jqXHR: ' + jqXHR + ', Status: ' + textStatus + ', Error: '+ errorThrown);
            //alert('There was an error loading more.');
        },
        complete: function () {
            $container.find(".loading").remove();
        }
    });
    return false;
};

function makeLastRightBarSectionSticky() {
    //Sticky right bar is only for wide screen
    if (!rightBarStickyNeeded())
        return;

    //Grab the last column and section on the page.
    var $rightBarColumn = $('.posts').last().find('.right-bar-column').last();
    var $rightBarSection = $rightBarColumn.find('.right-bar-section').last();

    if ($rightBarColumn && $rightBarSection) {
        //Set column height to match the parent container height. This sets the boundaries for the section inside.
        //For the images that affect the height of the total list we need default height set on for sticky right bar height calculation because getting the section height usually happens before all images load in a list.
        // .article-thumbnail img (in main.css)
        $rightBarColumn.addClass('rightbar-is-sticky');
        var parentHeight = $rightBarColumn.parent().outerHeight();

        var columnHeight = parentHeight;
        var sectionHeight = $rightBarSection.outerHeight();
        var windowHeight = $(window).height();

        //Don't do sticky if there's no room for it.
        if (sectionHeight >= columnHeight || columnHeight < windowHeight)
            return;

        $rightBarColumn.height(parentHeight);
        //Note the waypoint is attached to the right bar column that does not move around. If we attach to the section that sticks and scrolls sometimes the waypoint trigger does not work correctly. We use the offset on the column to find the section trigger point.
        $rightBarColumn.waypoint(function (direction) {
            //During scroll down towards bottom of page, when bottom of right bar section becomes visible in window make it stick (fixed) to the bottom of the screen.
            if (direction == "down") {
                $rightBarSection.removeClass('unstuck').addClass('stuck');
            }
            //During scroll up towards top of page, when top of right bar column becomes visible in window remove all sticky styles so the section goes back to its original placement.
            else if (direction == "up") {
                $rightBarSection.removeClass('stuck').removeClass('unstuck');
            }
        },
            {
                offset: function () {
                    var $rightBarSection = $(this.element).find('.right-bar-section').last();
                    var topOffset = windowHeight - $rightBarSection.outerHeight();
                    return topOffset;
                }
            });
        $rightBarColumn.waypoint(function (direction) {
            //During scroll down towards bottom of page, when bottom of right bar column becomes visible in window unstick the section so it scrolls with the page.
            if (direction == "down") {
                $rightBarSection.removeClass('stuck').addClass('unstuck');
            }
            //During scroll up towards top of page, when bottom of right bar column becomes visible in window make the section stick (fixed) to the bottom of the screen.
            else if (direction == "up") {
                $rightBarSection.removeClass('unstuck').addClass('stuck');
            }
        },
            {
                offset: 'bottom-in-view' //When bottom edge of column hits the bottom edge of window
            });
    }
}

function defineAndRefreshDynamicPosition(slotName, slotSizes, slotDivId) {
    if (slotSizes === "") {
        if (googletag && window.constant.dfpAdConfig.dynamicPositions) {
            const result = window.constant.dfpAdConfig.dynamicPositions.filter(el => {
                return el['name'] === slotName;
            });
            if (result && $.isArray(result) && result.length > 0) {
                slotSizes = result[0].sizes;
            }
        }
    }
    if (slotName && slotSizes && slotDivId) {
        googletag.cmd.push(function () {
            var dynamicSlot = googletag.defineSlot('/' + window.constant.dfpAccountId + '/' + slotName, slotSizes, slotDivId).addService(googletag.pubads());
            googletag.display(slotDivId);
            googletag.pubads().refresh([dynamicSlot]);
        });
    }
}

function findAndLoadDynamicAds(data) {
    $data = $(data);
    $dynamicAds = $data.find("." + window.constant.dfpDynamicAdCssClass);
    $dynamicAds.each(function (index) {
        var name = $(this).data("dfpPositionName");
        var sizes = $(this).data("dfpPositionSizes");
        var divId = $(this).attr("id");
        defineAndRefreshDynamicPosition(name, sizes, divId);
    });
}

$(function () {
    $(document).on('click', '.posts-load-more', loadMorePosts);
});;

function isRightBarStickyNeeded() {
    return $(window).width() > 992;
}

function makeStaticRightBarSticky() {

    if (isRightBarStickyNeeded()) {
        $('.right-bar-column').each(function (i, obj) {
            var $rightBarColumn = $(this);
            var $rightBarSection = $rightBarColumn.find('.right-bar-section').last();
            var windowHeight = $(window).height();
            var rightbarCount = $('.right-bar-column').length;

            if ($rightBarColumn && $rightBarSection) {
                //Set column height to match the left container, default to parent container height. This sets the boundaries for the section inside.
                var $itemHeightToMatch = $rightBarColumn.parent().find('.col-md-8').first() ? $rightBarColumn.parent().find('.col-md-8').first() : $rightBarColumn.parent();

                var rightColumnHeight = $itemHeightToMatch.outerHeight();
                var rightSectionHeight = $rightBarSection.outerHeight();
                $rightBarColumn.addClass('rightbar-is-sticky');
                //Defaults
                var topOffset = windowHeight - rightSectionHeight;
                var bottomOffset = 'bottom-in-view';

                //Don't do sticky if there' s no room for it or if the column is smaller than the window to prevent awkward overlapping
                if (rightSectionHeight + 150 >= rightColumnHeight || rightColumnHeight < windowHeight) {
                    return true;
                }


                $rightBarColumn.height(rightColumnHeight);

                // search pages have an extra filter widget that isn't sticky; need to remove the height when calculating sticky-able height
                $searchFilter = $rightBarColumn.find('.mobile-minitablet-smdesktop-hide-element');
                if ($searchFilter.length) {
                    topOffset -= $searchFilter.last().height();
                }

                //to avoid overlapping widgets and dividers, make sure the previous/next div is not a horizontal widget/divider
                var $parentPost = $rightBarColumn.parents('.posts');
                var div = $parentPost.prevAll('div');
                var nextDiv = $parentPost.nextAll('div');
                var hasDividerPrev = $(div[0]).hasClass('horizontal-widget') || $(div[0]).hasClass('more-posts-divider');
                var hasDividerNext = $(nextDiv[0]).hasClass('horizontal-widget') || $(nextDiv[0]).hasClass('more-posts-divider') || ($parentPost.next('.horizontal-widget').length);

                //hides whatever whitespaces is in the rightbarsection but isn't visible
                if (hasDividerNext || i == rightbarCount - 1)
                    $rightBarSection.css("background", "transparent");


                $rightBarColumn.waypoint(function (direction) {
                    //During scroll down towards bottom of page, when bottom of right bar section becomes visible in window make it stick (fixed) to the bottom of the screen.
                    if (direction == "down") {
                        $rightBarSection.removeClass('unstuck').addClass('stuck');
                    }
                    //During scroll up towards top of page, when top of right bar column becomes visible in window remove all sticky styles so the section goes back to its original placement.
                    else if (direction == "up") {
                        $rightBarSection.removeClass('stuck').removeClass('unstuck');
                    }
                },
                    {
                        offset: topOffset
                    });

                $rightBarColumn.waypoint(function (direction) {
                    //During scroll down towards bottom of page, when bottom of right bar column becomes visible in window unstick the section so it scrolls with the page.
                    if (direction == "down") {
                        $rightBarSection.removeClass('stuck').addClass('unstuck');
                    }
                    //During scroll up towards top of page, when bottom of right bar column becomes visible in window make the section stick (fixed) to the bottom of the screen.
                    else if (direction == "up") {
                        $rightBarSection.removeClass('unstuck').addClass('stuck');
                    }
                },
                    {
                        offset: bottomOffset
                    });
            }
        });
    }
}

function trackTopAdHeight() {
    if (!isRightBarStickyNeeded())
        return;

    //Recalculates trigger points when top02 ad expands/contracts
    var observer = new MutationObserver(function (mutations) {
        for (var i = 0; i < mutations.length; i++) {
            var mutation = mutations[i];
            if (mutation.type == 'attributes' && mutation.attributeName == "style") {
                Waypoint.refreshAll();
            }
        }
    });

    var oopTop02 = document.getElementById('div-oop-gpt-ad-top02');
    if (oopTop02 != null) {
        observer.observe(oopTop02, {
            attributes: true,
            childList: true,
            subtree: true
        });
    }
}

function trackPrestitialScroll() {
    if (!isRightBarStickyNeeded())
        return;

    var oopPrestitial = document.getElementById('prestitialWrapper');
    if (oopPrestitial != null) {
        //Recalculates trigger points when user leaves the prestitial
        $('#prestitialWrapper').mouseleave(function () {
            Waypoint.refreshAll();
        })
    }
}

//This is called in layout on slotRenderEnded event
function RecreateRightBar() {
    if (isRightBarStickyNeeded()) {
        if ($('.right-bar-column').first().hasClass('rightbar-is-sticky')) {
            // console.log("RightBar recreated after ads load");
            RemoveSticky();
            makeStaticRightBarSticky();
        }
    }
}

function RemoveSticky() {
    $('.right-bar-column').each(function (i, obj) {
        $(this).height('auto');
        $(this).removeClass('rightbar-is-sticky');
    });
    $('.right-bar-section.stuck').removeClass('stuck');
    $('.right-bar-section.unstuck').removeClass('unstuck');
    Waypoint.destroyAll();
}


$(window).on('load', function () {

    //Make sticky after all ads have loaded to ensure height calculations are correct
    makeStaticRightBarSticky();

    //Recalculate trigger points when oop ads affects height
    trackTopAdHeight();
    trackPrestitialScroll();

});

//Detect window resize and disable sticky if needed
$(window).resize(function () {
    if (isRightBarStickyNeeded()) {
        if ($('.right-bar-column').first().hasClass('rightbar-is-sticky')) {
            Waypoint.refreshAll(); //Recalculate trigger points on window resize. Window height may have changed.
        }
        else { // recreate it again
            makeStaticRightBarSticky();
        }
    }
    else {
        if ($('.right-bar-column').first().hasClass('rightbar-is-sticky')) {
            RemoveSticky() //No right sidebar. Remove existing waypoints to avoid floating sidebars out of place.
        }
    }
});
;