1#@!#!123s

: / home5 / rakcha / www / admin / assets / plugins / counterup /
Filename : jquery.waypoints.min.js
back
/*!

Waypoints - 4.0.1

Copyright © 2011-2016 Caleb Troughton

Licensed under the MIT license.

https://github.com/imakewebthings/waypoints/blob/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.Context.refreshAll()

    for (var waypointKey in allWaypoints) {

      allWaypoints[waypointKey].enabled = true

    }

    return this

  }



  /* 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

    if (!Waypoint.windowContext) {

      Waypoint.windowContext = true

      Waypoint.windowContext = new Context(window)

    }



    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)

    var isWindow = this.element == this.element.window

    if (horizontalEmpty && verticalEmpty && !isWindow) {

      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]

        if (waypoint.triggerPoint === null) {

          continue

        }

        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 = Math.floor(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)

  }

}())

;