(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 );

      };

  }()),

  //  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 = {

        // 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, animate;

        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)

            animate = function () {

              Popcorn.timeUpdate( that, {} );

              that.trigger( "timeupdate" );

              requestAnimFrame( animate );

            };

            requestAnimFrame( animate );

          } else {

            that.data.timeUpdateFunction = function( event ) {

              Popcorn.timeUpdate( that, event );

            };

            if ( !that.isDestroyed ) {

              that.media.addEventListener( "timeupdate", that.data.timeUpdateFunction, 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++;

      }

      return size;

    },

    isArray: Array.isArray || function( array ) {

      return toString.call( array ) === "[object Array]";

    },

    nop: function() {},

    position: function( elem ) {

      var clientRect = elem.getBoundingClientRect(),

          bounds = {},

          doc = elem.ownerDocument,

          docElem = document.documentElement,

          body = document.body,

          clientTop, clientLeft, scrollTop, scrollLeft, top, left;

      //  Determine correct clientTop/Left

      clientTop = docElem.clientTop || body.clientTop || 0;

      clientLeft = docElem.clientLeft || body.clientLeft || 0;

      //  Determine correct scrollTop/Left

      scrollTop = ( global.pageYOffset && docElem.scrollTop || body.scrollTop );

      scrollLeft = ( global.pageXOffset && docElem.scrollLeft || body.scrollLeft );

      //  Temp top/left

      top = Math.ceil( clientRect.top + scrollTop - clientTop );

      left = Math.ceil( clientRect.left + scrollLeft - clientLeft );

      for ( var p in clientRect ) {

        bounds[ p ] = Math.round( clientRect[ p ] );

      }

      return Popcorn.extend({}, bounds, { top: top, left: left });

    },

    disable: function( instance, plugin ) {

      var disabled = instance.data.disabled;

      if ( disabled.indexOf( plugin ) === -1 ) {

        disabled.push( plugin );

      }

      return instance;

    },

    enable: function( instance, plugin ) {

      var disabled = instance.data.disabled,

          index = disabled.indexOf( plugin );

      if ( index > -1 ) {

        disabled.splice( index, 1 );

      }

      return instance;

    },

    destroy: function( instance ) {

      var events = instance.data.events,

          singleEvent, item, fn;

      //  Iterate through all events and remove them