(function(global, document) {

  // Popcorn.js does not support archaic browsers

  if ( !document.addEventListener ) {

    global.Popcorn = {

      isSupported: false

    };

    var methods = ( "forEach extend effects error guid sizeOf isArray nop position disable enable destroy " +

          "addTrackEvent removeTrackEvent getTrackEvents getTrackEvent getLastTrackEventId " +

          "timeUpdate plugin removePlugin compose effect parser xhr getJSONP getScript" ).split(/\s+/);

    while ( methods.length ) {

      global.Popcorn[ methods.shift() ] = function() {};

    }

    return;

  }

  var

  AP = Array.prototype,

  OP = Object.prototype,

  forEach = AP.forEach,

  slice = AP.slice,

  hasOwn = OP.hasOwnProperty,

  toString = OP.toString,

  // Copy global Popcorn (may not exist)

  _Popcorn = global.Popcorn,

  //  ID string matching

  rIdExp  = /^(#([\w\-\_\.]+))$/,

  //  Ready fn cache

  readyStack = [],

  readyBound = false,

  readyFired = false,

  //  Non-public internal data object

  internal = {

    events: {

      hash: {},

      apis: {}

    }

  },

  //  Non-public `requestAnimFrame`

  //  http://paulirish.com/2011/requestanimationframe-for-smart-animating/

  requestAnimFrame = (function(){

    return global.requestAnimationFrame ||

      global.webkitRequestAnimationFrame ||

      global.mozRequestAnimationFrame ||

      global.oRequestAnimationFrame ||

      global.msRequestAnimationFrame ||

      function( callback, element ) {

        global.setTimeout( callback, 16 );

      };

  }()),

  refresh = function( obj ) {

    var currentTime = obj.media.currentTime,

      animation = obj.options.frameAnimation,

      disabled = obj.data.disabled,

      tracks = obj.data.trackEvents,

      animating = tracks.animating,

      start = tracks.startIndex,

      registryByName = Popcorn.registryByName,

      animIndex = 0,

      byStart, natives, type;

    start = Math.min( start + 1, tracks.byStart.length - 2 );

    while ( start > 0 && tracks.byStart[ start ] ) {

      byStart = tracks.byStart[ start ];

      natives = byStart._natives;

      type = natives && natives.type;

      if ( !natives ||

          ( !!registryByName[ type ] || !!obj[ type ] ) ) {

        if ( ( byStart.start <= currentTime && byStart.end > currentTime ) &&

                disabled.indexOf( type ) === -1 ) {

          if ( !byStart._running ) {

            byStart._running = true;

            natives.start.call( obj, null, byStart );

            // if the 'frameAnimation' option is used,

            // push the current byStart object into the `animating` cue

            if ( animation &&

                ( byStart && byStart._running && byStart.natives.frame ) ) {

              natives.frame.call( obj, null, byStart, currentTime );

            }

          }

        } else if ( byStart._running === true ) {

          byStart._running = false;

          natives.end.call( obj, null, byStart );

          if ( animation && byStart._natives.frame ) {

            animIndex = animating.indexOf( byStart );

            if ( animIndex >= 0 ) {

              animating.splice( animIndex, 1 );

            }

          }

        }

      }

      start--;

    }

  },

  //  Declare constructor

  //  Returns an instance object.

  Popcorn = function( entity, options ) {

    //  Return new Popcorn object

    return new Popcorn.p.init( entity, options || null );

  };

  //  Popcorn API version, automatically inserted via build system.

  Popcorn.version = "@VERSION";

  //  Boolean flag allowing a client to determine if Popcorn can be supported

  Popcorn.isSupported = true;

  //  Instance caching

  Popcorn.instances = [];

  //  Declare a shortcut (Popcorn.p) to and a definition of

  //  the new prototype for our Popcorn constructor

  Popcorn.p = Popcorn.prototype = {

    init: function( entity, options ) {

      var matches;

      //  Supports Popcorn(function () { /../ })

      //  Originally proposed by Daniel Brooks

      if ( typeof entity === "function" ) {

        //  If document ready has already fired

        if ( document.readyState === "interactive" || document.readyState === "complete" ) {

          entity( document, Popcorn );

          return;

        }

        //  Add `entity` fn to ready stack

        readyStack.push( entity );

        //  This process should happen once per page load

        if ( !readyBound ) {

          //  set readyBound flag

          readyBound = true;

          var DOMContentLoaded  = function() {

            readyFired = true;

            //  Remove global DOM ready listener

            document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );

            //  Execute all ready function in the stack

            for ( var i = 0, readyStackLength = readyStack.length; i < readyStackLength; i++ ) {

              readyStack[ i ].call( document, Popcorn );

            }

            //  GC readyStack

            readyStack = null;

          };

          //  Register global DOM ready listener

          document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

        }

        return;

      }

      //  Check if entity is a valid string id

      matches = rIdExp.exec( entity );

      //  Get media element by id or object reference

      this.media = matches && matches.length && matches[ 2 ] ?

                     document.getElementById( matches[ 2 ] ) :

                     entity;

      //  Create an audio or video element property reference

      this[ ( this.media.nodeName && this.media.nodeName.toLowerCase() ) || "video" ] = this.media;

      //  Register new instance

      Popcorn.instances.push( this );

      this.options = options || {};

      this.isDestroyed = false;

      this.data = {

        // Executed by either timeupdate event or in rAF loop

        timeUpdate: Popcorn.nop,

        // Allows disabling a plugin per instance

        disabled: [],

        // Stores DOM event queues by type

        events: {},

        // Stores Special event hooks data

        hooks: {},

        // Store track event history data

        history: [],

        // Stores ad-hoc state related data]

        state: {

          volume: this.media.volume

        },

        // Store track event object references by trackId

        trackRefs: {},

        // Playback track event queues

        trackEvents: {

          byStart: [{

            start: -1,

            end: -1

          }],

          byEnd: [{

            start: -1,

            end: -1

          }],

          animating: [],

          startIndex: 0,

          endIndex: 0,

          previousUpdateTime: -1

        }

      };

      //  Wrap true ready check

      var isReady = function( that ) {

        var duration, videoDurationPlus;

        if ( that.media.readyState >= 2 ) {

          //  Adding padding to the front and end of the arrays

          //  this is so we do not fall off either end

          duration = that.media.duration;

          //  Check for no duration info (NaN)

          videoDurationPlus = duration != duration ? Number.MAX_VALUE : duration + 1;

          Popcorn.addTrackEvent( that, {

            start: videoDurationPlus,

            end: videoDurationPlus

          });

          if ( that.options.frameAnimation ) {

            //  if Popcorn is created with frameAnimation option set to true,

            //  requestAnimFrame is used instead of "timeupdate" media event.

            //  This is for greater frame time accuracy, theoretically up to

            //  60 frames per second as opposed to ~4 ( ~every 15-250ms)

            that.data.timeUpdate = function () {

              Popcorn.timeUpdate( that, {} );

              that.trigger( "timeupdate" );

              !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

            };

            !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

          } else {

            that.data.timeUpdate = function( event ) {

              Popcorn.timeUpdate( that, event );

            };

            if ( !that.isDestroyed ) {

              that.media.addEventListener( "timeupdate", that.data.timeUpdate, false );

            }

          }

        } else {

          global.setTimeout(function() {

            isReady( that );

          }, 1 );

        }

      };

      isReady( this );

      return this;

    }

  };

  //  Extend constructor prototype to instance prototype

  //  Allows chaining methods to instances

  Popcorn.p.init.prototype = Popcorn.p;

  Popcorn.forEach = function( obj, fn, context ) {

    if ( !obj || !fn ) {

      return {};

    }

    context = context || this;

    var key, len;

    // Use native whenever possible

    if ( forEach && obj.forEach === forEach ) {

      return obj.forEach( fn, context );

    }

    if ( toString.call( obj ) === "[object NodeList]" ) {

      for ( key = 0, len = obj.length; key < len; key++ ) {

        fn.call( context, obj[ key ], key, obj );

      }

      return obj;

    }

    for ( key in obj ) {

      if ( hasOwn.call( obj, key ) ) {

        fn.call( context, obj[ key ], key, obj );

      }

    }

    return obj;

  };

  Popcorn.extend = function( obj ) {

    var dest = obj, src = slice.call( arguments, 1 );

    Popcorn.forEach( src, function( copy ) {

      for ( var prop in copy ) {

        dest[ prop ] = copy[ prop ];

      }

    });

    return dest;

  };

  // A Few reusable utils, memoized onto Popcorn

  Popcorn.extend( Popcorn, {

    noConflict: function( deep ) {

      if ( deep ) {

        global.Popcorn = _Popcorn;

      }

      return Popcorn;

    },

    error: function( msg ) {

      throw new Error( msg );

    },

    guid: function( prefix ) {

      Popcorn.guid.counter++;

      return  ( prefix ? prefix : "" ) + ( +new Date() + Popcorn.guid.counter );

    },

    sizeOf: function( obj ) {

      var size = 0;

      for ( var prop in obj ) {

        size++;