defaultOptions =

# How long should it take for the bar to animate to a new
# point after receiving it
catchupTime: 100

# How quickly should the bar be moving before it has any progress
# info from a new source in %/ms
initialRate: .03

# What is the minimum amount of time the bar should be on the
# screen.  Irrespective of this number, the bar will always be on screen for
# 33 * (100 / maxProgressPerFrame) + ghostTime ms.
minTime: 250

# What is the minimum amount of time the bar should sit after the last
# update before disappearing
ghostTime: 100

# Its easy for a bunch of the bar to be eaten in the first few frames
# before we know how much there is to load.  This limits how much of
# the bar can be used per frame
maxProgressPerFrame: 20

# This tweaks the animation easing
easeFactor: 1.25

# Should pace automatically start when the page is loaded, or should it wait for `start` to
# be called?  Always false if pace is loaded with AMD or CommonJS.
startOnPageLoad: true

# Should we restart the browser when pushState or replaceState is called?  (Generally
# means ajax navigation has occured)
restartOnPushState: true

# Should we show the progress bar for every ajax request (not just regular or ajax-y page
# navigation)? Set to false to disable.
#
# If so, how many ms does the request have to be running for before we show the progress?
restartOnRequestAfter: 500

# What element should the pace element be appended to on the page?
target: 'body'

elements:
  # How frequently in ms should we check for the elements being tested for
  # using the element monitor?
  checkInterval: 100

  # What elements should we wait for before deciding the page is fully loaded (not required)
  selectors: ['body']

eventLag:
  # When we first start measuring event lag, not much is going on in the browser yet, so it's
  # not uncommon for the numbers to be abnormally low for the first few samples.  This configures
  # how many samples we need before we consider a low number to mean completion.
  minSamples: 10

  # How many samples should we average to decide what the current lag is?
  sampleCount: 3

  # Above how many ms of lag is the CPU considered busy?
  lagThreshold: 3

ajax:
  # Which HTTP methods should we track?
  trackMethods: ['GET']

  # Should we track web socket connections?
  trackWebSockets: true

  # A list of regular expressions or substrings of URLS we should ignore (for both tracking and restarting)
  ignoreURLs: []

now = ->

performance?.now?() ? +new Date

requestAnimationFrame = window.requestAnimationFrame or window.mozRequestAnimationFrame or

window.webkitRequestAnimationFrame or window.msRequestAnimationFrame

cancelAnimationFrame = window.cancelAnimationFrame or window.mozCancelAnimationFrame

if not requestAnimationFrame?

requestAnimationFrame = (fn) ->
  setTimeout fn, 50

cancelAnimationFrame = (id) ->
  clearTimeout id

runAnimation = (fn) ->

last = now()
tick = ->
  diff = now() - last

  if diff >= 33
    # Don't run faster than 30 fps

    last = now()
    fn diff, ->
      requestAnimationFrame tick
  else
    setTimeout tick, (33 - diff)

tick()

result = (obj, key, args…) ->

if typeof obj[key] is 'function'
  obj[key](args...)
else
  obj[key]

extend = (out, sources…) ->

for source in sources when source
  for own key, val of source
    if out[key]? and typeof out[key] is 'object' and val? and typeof val is 'object'
      extend(out[key], val)
    else
      out[key] = val
out

avgAmplitude = (arr) ->

sum = count = 0
for v in arr
  sum += Math.abs(v)
  count++

sum / count

getFromDOM = (key='options', json=true) ->

el = document.querySelector "[data-pace-#{ key }]"

return unless el

data = el.getAttribute "data-pace-#{ key }"

return data if not json

try
  return JSON.parse data
catch e
  console?.error "Error parsing inline pace options", e

class Evented

on: (event, handler, ctx, once=false) ->
  @bindings ?= {}
  @bindings[event] ?= []
  @bindings[event].push {handler, ctx, once}

once: (event, handler, ctx) ->
  @on(event, handler, ctx, true)

off: (event, handler) ->
  return unless @bindings?[event]?

  if not handler?
    delete @bindings[event]
  else
    i = 0
    while i < @bindings[event].length
      if @bindings[event][i].handler is handler
        @bindings[event].splice i, 1
      else
        i++

trigger: (event, args...) ->
  if @bindings?[event]
    i = 0
    while i < @bindings[event].length
      {handler, ctx, once} = @bindings[event][i]

      handler.apply(ctx ? @, args)

      if once
        @bindings[event].splice i, 1
      else
        i++

Pace = window.Pace or {} window.Pace = Pace

extend Pace, Evented

options = Pace.options = extend {}, defaultOptions, window.paceOptions, getFromDOM()

for source in ['ajax', 'document', 'eventLag', 'elements']

# true enables them without configuration, so we grab the config from the defaults
if options[source] is true
  options[source] = defaultOptions[source]

class NoTargetError extends Error

class Bar

constructor: ->
  @progress = 0

getElement: ->
  if not @el?
    targetElement = document.querySelector options.target

    if not targetElement
      throw new NoTargetError

    @el = document.createElement 'div'
    @el.className = "pace pace-active"

    document.body.className = document.body.className.replace /pace-done/g, ''
    document.body.className += ' pace-running'

    @el.innerHTML = '''
    <div class="pace-progress">
      <div class="pace-progress-inner"></div>
    </div>
    <div class="pace-activity"></div>
    '''
    if targetElement.firstChild?
      targetElement.insertBefore @el, targetElement.firstChild
    else
      targetElement.appendChild @el

  @el

finish: ->
  el = @getElement()

  el.className = el.className.replace 'pace-active', ''
  el.className += ' pace-inactive'

  document.body.className = document.body.className.replace 'pace-running', ''
  document.body.className += ' pace-done'

update: (prog) ->
  @progress = prog

  do @render

destroy: ->
  try
    @getElement().parentNode.removeChild(@getElement())
  catch NoTargetError

  @el = undefined

render: ->
  if not document.querySelector(options.target)?
    return false

  el = @getElement()

  transform = "translate3d(#{ @progress }%, 0, 0)"
  for key in ['webkitTransform', 'msTransform', 'transform']
    el.children[0].style[key] = transform

  if not @lastRenderedProgress or @lastRenderedProgress|0 != @progress|0
    # The whole-part of the number has changed

    el.children[0].setAttribute 'data-progress-text', "#{ @progress|0 }%"

    if @progress >= 100
      # We cap it at 99 so we can use prefix-based attribute selectors
      progressStr = '99'
    else
      progressStr = if @progress < 10 then "0" else ""
      progressStr += @progress|0

    el.children[0].setAttribute 'data-progress', "#{ progressStr }"

  @lastRenderedProgress = @progress

done: ->
  @progress >= 100

class Events

constructor: ->
  @bindings = {}

trigger: (name, val) ->
  if @bindings[name]?
    for binding in @bindings[name]
      binding.call @, val

on: (name, fn) ->
  @bindings[name] ?= []
  @bindings[name].push fn

_XMLHttpRequest = window.XMLHttpRequest _XDomainRequest = window.XDomainRequest _WebSocket = window.WebSocket

extendNative = (to, from) ->

for key of from::
  try
    if not to[key]? and typeof from[key] isnt 'function'
      if typeof Object.defineProperty is 'function'
        Object.defineProperty(to, key, {
           get: ->
               return from::[key];
            ,
            configurable: true,
            enumerable: true })
      else
        to[key] = from::[key]
  catch e

ignoreStack = []

Pace.ignore = (fn, args…) ->

ignoreStack.unshift 'ignore'
ret = fn(args...)
ignoreStack.shift()
ret

Pace.track = (fn, args…) ->

ignoreStack.unshift 'track'
ret = fn(args...)
ignoreStack.shift()
ret

shouldTrack = (method='GET') ->

if ignoreStack[0] is 'track'
  return 'force'

if not ignoreStack.length and options.ajax
  if method is 'socket' and options.ajax.trackWebSockets
    return true
  else if method.toUpperCase() in options.ajax.trackMethods
    return true

return false

# We should only ever instantiate one of these class RequestIntercept extends Events

constructor: ->
  super

  monitorXHR = (req) =>
    _open = req.open
    req.open = (type, url, async) =>
      if shouldTrack(type)
        @trigger 'request', {type, url, request: req}

      _open.apply req, arguments

  window.XMLHttpRequest = (flags) ->
    req = new _XMLHttpRequest(flags)

    monitorXHR req

    req

  try
    extendNative window.XMLHttpRequest, _XMLHttpRequest

  if _XDomainRequest?
    window.XDomainRequest = ->
      req = new _XDomainRequest

      monitorXHR req

      req

    try
      extendNative window.XDomainRequest, _XDomainRequest

  if _WebSocket? and options.ajax.trackWebSockets
    window.WebSocket = (url, protocols) =>
      if protocols?
        req = new _WebSocket(url, protocols)
      else
        req = new _WebSocket(url)

      if shouldTrack('socket')
        @trigger 'request', {type: 'socket', url, protocols, request: req}

      req

    try
      extendNative window.WebSocket, _WebSocket

_intercept = null getIntercept = ->

if not _intercept?
  _intercept = new RequestIntercept
_intercept

shouldIgnoreURL = (url) ->

for pattern in options.ajax.ignoreURLs
  if typeof pattern is 'string'
    if url.indexOf(pattern) isnt -1
      return true

  else
    if pattern.test(url)
      return true

return false

# If we want to start the progress bar # on every request, we need to hear the request # and then inject it into the new ajax monitor # start will have created.

getIntercept().on 'request', ({type, request, url}) ->

return if shouldIgnoreURL(url)

if not Pace.running and (options.restartOnRequestAfter isnt false or shouldTrack(type) is 'force')
  args = arguments

  after = options.restartOnRequestAfter or 0
  if typeof after is 'boolean'
    after = 0

  setTimeout ->
    if type is 'socket'
      stillActive = request.readyState < 2
    else
      stillActive = 0 < request.readyState < 4

    if stillActive
      Pace.restart()

      for source in Pace.sources
        if source instanceof AjaxMonitor
          source.watch args...
          break
  , after

class AjaxMonitor

constructor: ->
  @elements = []

  getIntercept().on 'request', => @watch arguments...

watch: ({type, request, url}) ->
  return if shouldIgnoreURL(url)

  if type is 'socket'
    tracker = new SocketRequestTracker(request)
  else
    tracker = new XHRRequestTracker(request)

  @elements.push tracker

class XHRRequestTracker

constructor: (request) ->
  @progress = 0

  if window.ProgressEvent?
    # We're dealing with a modern browser with progress event support

    size = null
    request.addEventListener 'progress', (evt) =>
      if evt.lengthComputable
        @progress = 100 * evt.loaded / evt.total
      else
        # If it's chunked encoding, we have no way of knowing the total length of the
        # response, all we can do is increment the progress with backoff such that we
        # never hit 100% until it's done.
        @progress = @progress + (100 - @progress) / 2
    , false

    for event in ['load', 'abort', 'timeout', 'error']
      request.addEventListener event, =>
        @progress = 100
      , false

  else
    _onreadystatechange = request.onreadystatechange
    request.onreadystatechange = =>
      if request.readyState in [0, 4]
        @progress = 100
      else if request.readyState is 3
        @progress = 50

      _onreadystatechange?(arguments...)

class SocketRequestTracker

constructor: (request) ->
  @progress = 0

  for event in ['error', 'open']
    request.addEventListener event, =>
      @progress = 100
    , false

class ElementMonitor

constructor: (options={}) ->
  @elements = []

  options.selectors ?= []
  for selector in options.selectors
    @elements.push new ElementTracker selector

class ElementTracker

constructor: (@selector) ->
  @progress = 0

  @check()

check: ->
  if document.querySelector(@selector)
    @done()
  else
    setTimeout (=> @check()),
      options.elements.checkInterval

done: ->
  @progress = 100

class DocumentMonitor

states:
  loading: 0
  interactive: 50
  complete: 100

constructor: ->
  @progress = @states[document.readyState] ? 100

  _onreadystatechange = document.onreadystatechange
  document.onreadystatechange = =>
    if @states[document.readyState]?
      @progress = @states[document.readyState]

    _onreadystatechange?(arguments...)

class EventLagMonitor

constructor: ->
  @progress = 0

  avg = 0

  samples = []

  points = 0
  last = now()
  interval = setInterval =>
    diff = now() - last - 50
    last = now()

    samples.push diff

    if samples.length > options.eventLag.sampleCount
      samples.shift()

    avg = avgAmplitude samples

    if ++points >= options.eventLag.minSamples and avg < options.eventLag.lagThreshold
      @progress = 100

      clearInterval interval
    else
      @progress = 100 * (3 / (avg + 3))

  , 50

class Scaler

constructor: (@source) ->
  @last = @sinceLastUpdate = 0
  @rate = options.initialRate
  @catchup = 0
  @progress = @lastProgress = 0

  if @source?
    @progress = result(@source, 'progress')

tick: (frameTime, val) ->
  val ?= result(@source, 'progress')

  if val >= 100
    @done = true

  if val == @last
    @sinceLastUpdate += frameTime
  else
    if @sinceLastUpdate
      @rate = (val - @last) / @sinceLastUpdate

    @catchup = (val - @progress) / options.catchupTime

    @sinceLastUpdate = 0
    @last = val

  if val > @progress
    # After we've got a datapoint, we have catchupTime to
    # get the progress bar to reflect that new data
    @progress += @catchup * frameTime

  scaling = (1 - Math.pow(@progress / 100, options.easeFactor))

  # Based on the rate of the last update, we preemptively update
  # the progress bar, scaling it so it can never hit 100% until we
  # know it's done.
  @progress += scaling * @rate * frameTime

  @progress = Math.min(@lastProgress + options.maxProgressPerFrame, @progress)

  @progress = Math.max(0, @progress)
  @progress = Math.min(100, @progress)

  @lastProgress = @progress

  @progress

sources = null scalers = null bar = null uniScaler = null animation = null cancelAnimation = null Pace.running = false

handlePushState = ->

if options.restartOnPushState
  Pace.restart()

# We reset the bar whenever it looks like an ajax navigation has occured. if window.history.pushState?

_pushState = window.history.pushState
window.history.pushState = ->
  handlePushState()

  _pushState.apply window.history, arguments

if window.history.replaceState?

_replaceState = window.history.replaceState
window.history.replaceState = ->
  handlePushState()

  _replaceState.apply window.history, arguments

SOURCE_KEYS =

ajax: AjaxMonitor
elements: ElementMonitor
document: DocumentMonitor
eventLag: EventLagMonitor

do init = ->

Pace.sources = sources = []

for type in ['ajax', 'elements', 'document', 'eventLag']
  if options[type] isnt false
    sources.push new SOURCE_KEYS[type](options[type])

for source in options.extraSources ? []
  sources.push new source(options)

Pace.bar = bar = new Bar

# Each source of progress data has it's own scaler to smooth its output
scalers = []

# We have an extra scaler for the final output to keep things looking nice as we add and
# remove sources
uniScaler = new Scaler

Pace.stop = ->

Pace.trigger 'stop'
Pace.running = false

bar.destroy()

# Not all browsers support cancelAnimationFrame
cancelAnimation = true

if animation?
  cancelAnimationFrame? animation
  animation = null

init()

Pace.restart = ->

Pace.trigger 'restart'
Pace.stop()
Pace.start()

Pace.go = ->

Pace.running = true

bar.render()

start = now()

cancelAnimation = false
animation = runAnimation (frameTime, enqueueNextFrame) ->
  # Every source gives us a progress number from 0 - 100
  # It's up to us to figure out how to turn that into a smoothly moving bar
  #
  # Their progress numbers can only increment.  We try to interpolate
  # between the numbers.

  remaining = 100 - bar.progress

  count = sum = 0
  done = true
  # A source is composed of a bunch of elements, each with a raw, unscaled progress
  for source, i in sources
    scalerList = scalers[i] ?= []

    elements = source.elements ? [source]

    # Each element is given it's own scaler, which turns its value into something
    # smoothed for display
    for element, j in elements
      scaler = scalerList[j] ?= new Scaler element

      done &= scaler.done

      continue if scaler.done

      count++
      sum += scaler.tick(frameTime)

  avg = sum / count

  bar.update uniScaler.tick(frameTime, avg)

  if bar.done() or done or cancelAnimation
    bar.update 100

    Pace.trigger 'done'

    setTimeout ->
      bar.finish()

      Pace.running = false

      Pace.trigger 'hide'
    , Math.max(options.ghostTime, Math.max(options.minTime - (now() - start), 0))
  else
    enqueueNextFrame()

Pace.start = (_options) ->

extend options, _options

Pace.running = true

try
  bar.render()
catch NoTargetError

# It's usually possible to render a bit before the document declares itself ready
if not document.querySelector('.pace')
  setTimeout Pace.start, 50
else
  Pace.trigger 'start'
  Pace.go()

if typeof define is 'function' and define.amd

# AMD
define ['pace'], -> Pace

else if typeof exports is 'object'

# CommonJS
module.exports = Pace

else

# Global
if options.startOnPageLoad
  Pace.start()