text: (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else {
  		var a = factory();
  		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
  	}
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  /******/
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// identity function for calling harmony imports with the correct context
  /******/ 	__webpack_require__.i = function(value) { return value; };
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 55);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var NODE_TYPE_ELEMENT = 1;
  var SNAKE_CASE_REGEXP = /[A-Z]/g;
  var EMAIL_REGEXP = /^[a-z0-9!#$%&'*+\/=?^_`{|}~.-]+@[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$/i;
  var ISO8086_REGEXP = /^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
  
  function noop() {}
  
  function isNull(o) {
    return o === null;
  }
  
  function isDefined(o) {
    return o !== undefined;
  }
  
  function isUndefined(o) {
    return o === undefined;
  }
  
  function isObject(obj) {
    return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object';
  }
  
  function isFunction(str) {
    return typeof str === 'function';
  }
  
  function isNumber(num) {
    return typeof num === 'number';
  }
  
  function isWindow(obj) {
    return utilities.isObject(obj) && obj.window === obj;
  }
  
  function isArray(array) {
    return Object.prototype.toString.call(array) === '[object Array]';
  }
  
  function isArrayLike(obj) {
    if (obj === null || utilities.isWindow(obj) || utilities.isFunction(obj) || utilities.isUndefined(obj)) {
      return false;
    }
  
    var length = obj.length;
  
    if (obj.nodeType === NODE_TYPE_ELEMENT && length) {
      return true;
    }
  
    return utilities.isString(obj) || utilities.isArray(obj) || length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj;
  }
  
  function isString(str) {
    return typeof str === 'string';
  }
  
  function isEmptyString(str) {
    return utilities.isString(str) && str.length === 0;
  }
  
  function isNotEmptyString(str) {
    return utilities.isString(str) && str.length !== 0;
  }
  
  function arrayLikeObjToArray(args) {
    return Array.prototype.slice.call(args);
  }
  
  function forEach(obj, iterator, context) {
    var key = void 0,
        length = void 0;
  
    if (obj) {
      if (isFunction(obj)) {
        for (key in obj) {
          // Need to check if hasOwnProperty exists,
          // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
          if (key !== 'prototype' && key !== 'length' && key !== 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {
            iterator.call(context, obj[key], key, obj);
          }
        }
      } else if (isArray(obj)) {
        var isPrimitive = (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object';
  
        for (key = 0, length = obj.length; key < length; key++) {
          if (isPrimitive || key in obj) {
            iterator.call(context, obj[key], key, obj);
          }
        }
      } else if (obj.forEach && obj.forEach !== forEach) {
        obj.forEach(iterator, context, obj);
      } else {
        for (key in obj) {
          if (obj.hasOwnProperty(key)) {
            iterator.call(context, obj[key], key, obj);
          }
        }
      }
    }
  
    return obj;
  }
  
  function snake_case(name, separator) {
    separator = separator || '_';
  
    return name.replace(SNAKE_CASE_REGEXP, function (letter, pos) {
      return (pos ? separator : '') + letter.toLowerCase();
    });
  }
  
  function isValidEmail(email) {
    if (!utilities.isString(email)) {
      return false;
    }
  
    return EMAIL_REGEXP.test(email.trim());
  }
  
  function extend(obj) {
    var arg = void 0,
        i = void 0,
        k = void 0;
  
    for (i = 1; i < arguments.length; i++) {
      arg = arguments[i];
      for (k in arg) {
        if (arg.hasOwnProperty(k)) {
          if (isObject(obj[k]) && !isNull(obj[k]) && isObject(arg[k])) {
            obj[k] = extend({}, obj[k], arg[k]);
          } else {
            obj[k] = arg[k];
          }
        }
      }
    }
  
    return obj;
  }
  
  function capitalize(s) {
    return s.charAt(0).toUpperCase() + s.slice(1);
  }
  
  function decapitalize(s) {
    return s.charAt(0).toLowerCase() + s.slice(1);
  }
  
  /**
   * This method works the same way array.prototype.map works but if the transformer returns undefine, then
   * it won't be added to the transformed Array.
   */
  function transformArray(array, transformer) {
    var transformedArray = [];
  
    array.forEach(function (item, index) {
      var transformedItem = transformer(item, index);
  
      if (utilities.isDefined(transformedItem)) {
        transformedArray.push(transformedItem);
      }
    });
  
    return transformedArray;
  }
  
  function toFixedDigits(num, digits) {
    var formattedNum = String(num);
  
    digits = utilities.isNumber(digits) ? digits : 0;
    num = utilities.isNumber(num) ? num : parseInt(num, 10);
    if (utilities.isNumber(num) && !isNaN(num)) {
      formattedNum = String(num);
      while (formattedNum.length < digits) {
        formattedNum = '0' + formattedNum;
      }
  
      return formattedNum;
    }
  
    return String(NaN);
  }
  
  function throttle(callback, delay) {
    var previousCall = new Date().getTime() - (delay + 1);
  
    return function () {
      var time = new Date().getTime();
  
      if (time - previousCall >= delay) {
        previousCall = time;
        callback.apply(this, arguments);
      }
    };
  }
  
  function debounce(callback, wait) {
    var timeoutId = void 0;
  
    return function () {
      if (timeoutId) {
        clearTimeout(timeoutId);
      }
      timeoutId = setTimeout(function () {
        callback.apply(this, arguments);
        timeoutId = undefined;
      }, wait);
    };
  }
  
  // a function designed to blow up the stack in a naive way
  // but it is ok for videoJs children components
  function treeSearch(root, getChildren, found) {
    var children = getChildren(root);
  
    for (var i = 0; i < children.length; i++) {
      if (found(children[i])) {
        return children[i];
      } else {
        var el = treeSearch(children[i], getChildren, found);
  
        if (el) {
          return el;
        }
      }
    }
  }
  
  function echoFn(val) {
    return function () {
      return val;
    };
  }
  
  // Note: Supported formats come from http://www.w3.org/TR/NOTE-datetime
  // and the iso8601 regex comes from http://www.pelagodesign.com/blog/2009/05/20/iso-8601-date-validation-that-doesnt-suck/
  function isISO8601(value) {
    if (utilities.isNumber(value)) {
      value = String(value); // we make sure that we are working with strings
    }
  
    if (!utilities.isString(value)) {
      return false;
    }
  
    return ISO8086_REGEXP.test(value.trim());
  }
  
  /**
   * Checks if the Browser is IE9 and below
   * @returns {boolean}
   */
  function isOldIE() {
    var version = utilities.getInternetExplorerVersion(navigator);
  
    if (version === -1) {
      return false;
    }
  
    return version < 10;
  }
  
  /**
   * Returns the version of Internet Explorer or a -1 (indicating the use of another browser).
   * Source: https://msdn.microsoft.com/en-us/library/ms537509(v=vs.85).aspx
   * @returns {number} the version of Internet Explorer or a -1 (indicating the use of another browser).
   */
  function getInternetExplorerVersion(navigator) {
    var rv = -1;
  
    if (navigator.appName === 'Microsoft Internet Explorer') {
      var ua = navigator.userAgent;
      var re = new RegExp('MSIE ([0-9]{1,}[.0-9]{0,})');
      var res = re.exec(ua);
  
      if (res !== null) {
        rv = parseFloat(res[1]);
      }
    }
  
    return rv;
  }
  
  /** * Mobile Utility functions ***/
  function isIDevice() {
    return (/iP(hone|ad)/.test(utilities.UA)
    );
  }
  
  function isMobile() {
    return (/iP(hone|ad|od)|Android|Windows Phone/.test(utilities.UA)
    );
  }
  
  function isIPhone() {
    return (/iP(hone|od)/.test(utilities.UA)
    );
  }
  
  function isAndroid() {
    return (/Android/.test(utilities.UA)
    );
  }
  
  var utilities = {
    UA: navigator.userAgent,
    noop: noop,
    isNull: isNull,
    isDefined: isDefined,
    isUndefined: isUndefined,
    isObject: isObject,
    isFunction: isFunction,
    isNumber: isNumber,
    isWindow: isWindow,
    isArray: isArray,
    isArrayLike: isArrayLike,
    isString: isString,
    isEmptyString: isEmptyString,
    isNotEmptyString: isNotEmptyString,
    arrayLikeObjToArray: arrayLikeObjToArray,
    forEach: forEach,
    snake_case: snake_case,
    isValidEmail: isValidEmail,
    extend: extend,
    capitalize: capitalize,
    decapitalize: decapitalize,
    transformArray: transformArray,
    toFixedDigits: toFixedDigits,
    throttle: throttle,
    debounce: debounce,
    treeSearch: treeSearch,
    echoFn: echoFn,
    isISO8601: isISO8601,
    isOldIE: isOldIE,
    getInternetExplorerVersion: getInternetExplorerVersion,
    isIDevice: isIDevice,
    isMobile: isMobile,
    isIPhone: isIPhone,
    isAndroid: isAndroid
  };
  
  module.exports = utilities;
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  exports.unique = unique;
  exports.noop = noop;
  exports.callbackTimeout = callbackTimeout;
  exports.createElementWithID = createElementWithID;
  exports.isPositiveInt = isPositiveInt;
  exports.stringEndsWith = stringEndsWith;
  exports.hideFlashEl = hideFlashEl;
  function unique(prefix) {
      var count = -1;
      return function (f) {
          return prefix + '_' + ++count;
      };
  }
  
  function noop() {}
  
  function callbackTimeout(timer, onSuccess, onTimeout) {
  
      var timeout = setTimeout(function () {
  
          onSuccess = noop;
          onTimeout();
      }, timer);
  
      return function () {
          clearTimeout(timeout);
          onSuccess.apply(this, arguments);
      };
  }
  
  function createElementWithID(parent, id) {
      var cleanContent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  
      var nEl = document.createElement('div');
      nEl.id = id;
      if (cleanContent) {
          parent.innerHTML = '';
      }
      parent.appendChild(nEl);
      return nEl;
  }
  
  function isPositiveInt(newVal, oldVal) {
      return !isNaN(parseFloat(newVal)) && isFinite(newVal) && newVal > 0 ? newVal : oldVal;
  }
  
  var endsWith = function () {
      if (String.prototype.endsWith) return String.prototype.endsWith;
      return function endsWith(searchString, position) {
          var subjectString = this.toString();
          if (position === undefined || position > subjectString.length) {
              position = subjectString.length;
          }
          position -= searchString.length;
          var lastIndex = subjectString.indexOf(searchString, position);
          return lastIndex !== -1 && lastIndex === position;
      };
  }();
  
  function stringEndsWith(string, search) {
      return endsWith.call(string, search);
  }
  
  function hideFlashEl(el) {
      // can't use display none or visibility none because will block flash in some browsers
      el.style.position = 'absolute';
      el.style.left = '-1px';
      el.style.top = '-1px';
      el.style.width = '1px';
      el.style.height = '1px';
  }
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  
  var xml = {};
  
  xml.strToXMLDoc = function strToXMLDoc(stringContainingXMLSource) {
    // IE 8
    if (typeof window.DOMParser === 'undefined') {
      var xmlDocument = new ActiveXObject('Microsoft.XMLDOM');
  
      xmlDocument.async = false;
      xmlDocument.loadXML(stringContainingXMLSource);
  
      return xmlDocument;
    }
  
    return parseString(stringContainingXMLSource);
  
    function parseString(stringContainingXMLSource) {
      var parser = new DOMParser();
      var parsedDocument = void 0;
  
      // Note: This try catch is to deal with the fact that on IE parser.parseFromString does throw an error but the rest of the browsers don't.
      try {
        parsedDocument = parser.parseFromString(stringContainingXMLSource, 'application/xml');
  
        if (isParseError(parsedDocument) || utilities.isEmptyString(stringContainingXMLSource)) {
          throw new Error();
        }
      } catch (e) {
        throw new Error('xml.strToXMLDOC: Error parsing the string: \'' + stringContainingXMLSource + '\'');
      }
  
      return parsedDocument;
    }
  
    function isParseError(parsedDocument) {
      try {
        // parser and parsererrorNS could be cached on startup for efficiency
        var parser = new DOMParser(),
            erroneousParse = parser.parseFromString('INVALID', 'text/xml'),
            parsererrorNS = erroneousParse.getElementsByTagName('parsererror')[0].namespaceURI;
  
        if (parsererrorNS === 'http://www.w3.org/1999/xhtml') {
          // In PhantomJS the parseerror element doesn't seem to have a special namespace, so we are just guessing here :(
          return parsedDocument.getElementsByTagName('parsererror').length > 0;
        }
  
        return parsedDocument.getElementsByTagNameNS(parsererrorNS, 'parsererror').length > 0;
      } catch (e) {
        // Note on IE parseString throws an error by itself and it will never reach this code. Because it will have failed before
      }
    }
  };
  
  xml.parseText = function parseText(sValue) {
    if (/^\s*$/.test(sValue)) {
      return null;
    }
    if (/^(?:true|false)$/i.test(sValue)) {
      return sValue.toLowerCase() === 'true';
    }
    if (isFinite(sValue)) {
      return parseFloat(sValue);
    }
    if (utilities.isISO8601(sValue)) {
      return new Date(sValue);
    }
  
    return sValue.trim();
  };
  
  xml.JXONTree = function JXONTree(oXMLParent) {
    var parseText = xml.parseText;
  
    // The document object is an especial object that it may miss some functions or attrs depending on the browser.
    // To prevent this problem with create the JXONTree using the root childNode which is a fully fleshed node on all supported
    // browsers.
    if (oXMLParent.documentElement) {
      return new xml.JXONTree(oXMLParent.documentElement);
    }
  
    if (oXMLParent.hasChildNodes()) {
      var sCollectedTxt = '';
  
      for (var oNode, sProp, vContent, nItem = 0; nItem < oXMLParent.childNodes.length; nItem++) {
        oNode = oXMLParent.childNodes.item(nItem);
  
        /* jshint bitwise: false*/
        if ((oNode.nodeType - 1 | 1) === 3) {
          sCollectedTxt += oNode.nodeType === 3 ? oNode.nodeValue.trim() : oNode.nodeValue;
        } else if (oNode.nodeType === 1 && !oNode.prefix) {
          sProp = utilities.decapitalize(oNode.nodeName);
          vContent = new xml.JXONTree(oNode);
          if (this.hasOwnProperty(sProp)) {
            if (this[sProp].constructor !== Array) {
              this[sProp] = [this[sProp]];
            }
            this[sProp].push(vContent);
          } else {
            this[sProp] = vContent;
          }
        }
      }
      if (sCollectedTxt) {
        this.keyValue = parseText(sCollectedTxt);
      }
    }
  
    // IE8 Stupid fix
    var hasAttr = typeof oXMLParent.hasAttributes === 'undefined' ? oXMLParent.attributes.length > 0 : oXMLParent.hasAttributes();
  
    if (hasAttr) {
      var oAttrib = void 0;
  
      for (var nAttrib = 0; nAttrib < oXMLParent.attributes.length; nAttrib++) {
        oAttrib = oXMLParent.attributes.item(nAttrib);
        this['@' + utilities.decapitalize(oAttrib.name)] = parseText(oAttrib.value.trim());
      }
    }
  };
  
  xml.JXONTree.prototype.attr = function (attr) {
    return this['@' + utilities.decapitalize(attr)];
  };
  
  xml.toJXONTree = function toJXONTree(xmlString) {
    var xmlDoc = xml.strToXMLDoc(xmlString);
  
    return new xml.JXONTree(xmlDoc);
  };
  
  /**
   * Helper function to extract the keyvalue of a JXONTree obj
   *
   * @param xmlObj {JXONTree}
   * return the key value or undefined;
   */
  xml.keyValue = function getKeyValue(xmlObj) {
    if (xmlObj) {
      return xmlObj.keyValue;
    }
  
    return undefined;
  };
  
  xml.attr = function getAttrValue(xmlObj, attr) {
    if (xmlObj) {
      return xmlObj['@' + utilities.decapitalize(attr)];
    }
  
    return undefined;
  };
  
  xml.encode = function encodeXML(str) {
    if (!utilities.isString(str)) {
      return undefined;
    }
  
    return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
  };
  
  xml.decode = function decodeXML(str) {
    if (!utilities.isString(str)) {
      return undefined;
    }
  
    return str.replace(/&apos;/g, '\'').replace(/&quot;/g, '"').replace(/&gt;/g, '>').replace(/&lt;/g, '<').replace(/&amp;/g, '&');
  };
  
  module.exports = xml;
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function VASTError(message, code) {
    this.message = 'VAST Error: ' + (message || '');
    if (code) {
      this.code = code;
    }
  }
  
  VASTError.prototype = new Error();
  VASTError.prototype.name = 'VAST Error';
  
  module.exports = VASTError;
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var VPAIDFLASHClient = __webpack_require__(12);
  var utilities = __webpack_require__(0);
  var VPAIDHTML5Tech = __webpack_require__(42);
  var VPAIDFlashTech = __webpack_require__(41);
  
  var vastUtil = {
  
    track: function track(URLMacros, variables) {
      var sources = vastUtil.parseURLMacros(URLMacros, variables);
      var trackImgs = [];
  
      sources.forEach(function (src) {
        var img = new Image();
  
        img.src = src;
        trackImgs.push(img);
      });
  
      return trackImgs;
    },
  
    parseURLMacros: function parseMacros(URLMacros, variables) {
      var parsedURLs = [];
  
      variables = variables || {};
  
      if (!variables.CACHEBUSTING) {
        variables.CACHEBUSTING = Math.round(Math.random() * 1.0e+10);
      }
  
      URLMacros.forEach(function (URLMacro) {
        parsedURLs.push(vastUtil._parseURLMacro(URLMacro, variables));
      });
  
      return parsedURLs;
    },
  
    parseURLMacro: function parseMacro(URLMacro, variables) {
      variables = variables || {};
  
      if (!variables.CACHEBUSTING) {
        variables.CACHEBUSTING = Math.round(Math.random() * 1.0e+10);
      }
  
      return vastUtil._parseURLMacro(URLMacro, variables);
    },
  
    _parseURLMacro: function parseMacro(URLMacro, variables) {
      variables = variables || {};
  
      utilities.forEach(variables, function (value, key) {
        //eslint-disable-next-line
        URLMacro = URLMacro.replace(new RegExp('\\[' + key + '\\\]', 'gm'), value);
      });
  
      return URLMacro;
    },
  
    parseDuration: function parseDuration(durationStr) {
      var durationRegex = /(\d\d):(\d\d):(\d\d)(\.(\d\d\d))?/;
      var match = void 0,
          durationInMs = void 0;
  
      if (utilities.isString(durationStr)) {
        match = durationStr.match(durationRegex);
        if (match) {
          durationInMs = parseHoursToMs(match[1]) + parseMinToMs(match[2]) + parseSecToMs(match[3]) + parseInt(match[5] || 0, 10);
        }
      }
  
      return isNaN(durationInMs) ? null : durationInMs;
  
      /** * local functions ***/
      function parseHoursToMs(hourStr) {
        return parseInt(hourStr, 10) * 60 * 60 * 1000;
      }
  
      function parseMinToMs(minStr) {
        return parseInt(minStr, 10) * 60 * 1000;
      }
  
      function parseSecToMs(secStr) {
        return parseInt(secStr, 10) * 1000;
      }
    },
  
    parseImpressions: function parseImpressions(impressions) {
      if (impressions) {
        impressions = utilities.isArray(impressions) ? impressions : [impressions];
  
        return utilities.transformArray(impressions, function (impression) {
          if (utilities.isNotEmptyString(impression.keyValue)) {
            return impression.keyValue;
          }
  
          return undefined;
        });
      }
  
      return [];
    },
  
    // We assume that the progress is going to arrive in milliseconds
    formatProgress: function formatProgress(progress) {
      var hours = void 0,
          minutes = void 0,
          seconds = void 0,
          milliseconds = void 0;
  
      hours = progress / (60 * 60 * 1000);
      hours = Math.floor(hours);
      minutes = progress / (60 * 1000) % 60;
      minutes = Math.floor(minutes);
      seconds = progress / 1000 % 60;
      seconds = Math.floor(seconds);
      milliseconds = progress % 1000;
  
      return utilities.toFixedDigits(hours, 2) + ':' + utilities.toFixedDigits(minutes, 2) + ':' + utilities.toFixedDigits(seconds, 2) + '.' + utilities.toFixedDigits(milliseconds, 3);
    },
  
    parseOffset: function parseOffset(offset, duration) {
      if (isPercentage(offset)) {
        return calculatePercentage(offset, duration);
      }
  
      return vastUtil.parseDuration(offset);
  
      /** * Local function ***/
      function isPercentage(offset) {
        var percentageRegex = /^\d+(\.\d+)?%$/g;
  
        return percentageRegex.test(offset);
      }
  
      function calculatePercentage(percentStr, duration) {
        if (duration) {
          return calcPercent(duration, parseFloat(percentStr.replace('%', '')));
        }
  
        return null;
      }
  
      function calcPercent(quantity, percent) {
        return quantity * percent / 100;
      }
    },
  
    // List of supported VPAID technologies
    VPAID_techs: [VPAIDFlashTech, VPAIDHTML5Tech],
  
    isVPAID: function isVPAIDMediaFile(mediaFile) {
      return Boolean(mediaFile) && mediaFile.apiFramework === 'VPAID';
    },
  
    findSupportedVPAIDTech: function findSupportedVPAIDTech(mimeType) {
      var i = void 0,
          len = void 0,
          VPAIDTech = void 0;
  
      for (i = 0, len = this.VPAID_techs.length; i < len; i += 1) {
        VPAIDTech = this.VPAID_techs[i];
        if (VPAIDTech.supports(mimeType)) {
          return VPAIDTech;
        }
      }
  
      return null;
    },
  
    isFlashSupported: function isFlashSupported() {
      return VPAIDFLASHClient.isSupported();
    },
  
    /**
     * Necessary step for VPAIDFLAShClient to know if flash is supported and not blocked.
     * IMPORTANT NOTE: This is an async test and needs to be run as soon as possible.
     *
     * @param vpaidFlashLoaderPath the path to the vpaidFlashLoader swf obj.
     */
    runFlashSupportCheck: function runFlashSupportCheck(vpaidFlashLoaderPath) {
      VPAIDFLASHClient.runFlashTest({ data: vpaidFlashLoaderPath });
    }
  
  };
  
  module.exports = vastUtil;
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /* jshint unused:false */
  
  var _verbosity = 0;
  var _prefix = '[videojs-vast-vpaid] ';
  
  function setVerbosity(v) {
    _verbosity = v;
  }
  
  function handleMsg(method, args) {
    if (args.length > 0 && typeof args[0] === 'string') {
      args[0] = _prefix + args[0];
    }
  
    if (method.apply) {
      method.apply(console, Array.prototype.slice.call(args));
    } else {
      method(Array.prototype.slice.call(args));
    }
  }
  
  function debug() {
    if (_verbosity < 4) {
      return;
    }
  
    if (typeof console.debug === 'undefined') {
      // IE 10 doesn't have a console.debug() function
      handleMsg(console.log, arguments);
    } else {
      handleMsg(console.debug, arguments);
    }
  }
  
  function log() {
    if (_verbosity < 3) {
      return;
    }
  
    handleMsg(console.log, arguments);
  }
  
  function info() {
    if (_verbosity < 2) {
      return;
    }
  
    handleMsg(console.info, arguments);
  }
  
  function warn() {
    if (_verbosity < 1) {
      return;
    }
  
    handleMsg(console.warn, arguments);
  }
  
  function error() {
    handleMsg(console.error, arguments);
  }
  
  var consoleLogger = {
    setVerbosity: setVerbosity,
    debug: debug,
    log: log,
    info: info,
    warn: warn,
    error: error
  };
  
  if (typeof console === 'undefined' || !console.log) {
    // no console available; make functions no-op
    consoleLogger.debug = function () {};
    consoleLogger.log = function () {};
    consoleLogger.info = function () {};
    consoleLogger.warn = function () {};
    consoleLogger.error = function () {};
  }
  
  module.exports = consoleLogger;
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  
  var dom = {};
  
  dom.isVisible = function isVisible(el) {
    var style = window.getComputedStyle(el);
  
    return style.visibility !== 'hidden';
  };
  
  dom.isHidden = function isHidden(el) {
    var style = window.getComputedStyle(el);
  
    return style.display === 'none';
  };
  
  dom.isShown = function isShown(el) {
    return !dom.isHidden(el);
  };
  
  dom.hide = function hide(el) {
    el.__prev_style_display_ = el.style.display;
    el.style.display = 'none';
  };
  
  dom.show = function show(el) {
    if (dom.isHidden(el)) {
      el.style.display = el.__prev_style_display_;
    }
    el.__prev_style_display_ = undefined;
  };
  
  dom.hasClass = function hasClass(el, cssClass) {
    var classes = void 0,
        i = void 0,
        len = void 0;
  
    if (utilities.isNotEmptyString(cssClass)) {
      if (el.classList) {
        return el.classList.contains(cssClass);
      }
  
      classes = utilities.isString(el.getAttribute('class')) ? el.getAttribute('class').split(/\s+/) : [];
      cssClass = cssClass || '';
  
      for (i = 0, len = classes.length; i < len; i += 1) {
        if (classes[i] === cssClass) {
          return true;
        }
      }
    }
  
    return false;
  };
  
  dom.addClass = function (el, cssClass) {
    var classes = void 0;
  
    if (utilities.isNotEmptyString(cssClass)) {
      if (el.classList) {
        return el.classList.add(cssClass);
      }
  
      classes = utilities.isString(el.getAttribute('class')) ? el.getAttribute('class').split(/\s+/) : [];
      if (utilities.isString(cssClass) && utilities.isNotEmptyString(cssClass.replace(/\s+/, ''))) {
        classes.push(cssClass);
        el.setAttribute('class', classes.join(' '));
      }
    }
  };
  
  dom.removeClass = function (el, cssClass) {
    var classes = void 0;
  
    if (utilities.isNotEmptyString(cssClass)) {
      if (el.classList) {
        return el.classList.remove(cssClass);
      }
  
      classes = utilities.isString(el.getAttribute('class')) ? el.getAttribute('class').split(/\s+/) : [];
      var newClasses = [];
      var i = void 0,
          len = void 0;
  
      if (utilities.isString(cssClass) && utilities.isNotEmptyString(cssClass.replace(/\s+/, ''))) {
        for (i = 0, len = classes.length; i < len; i += 1) {
          if (cssClass !== classes[i]) {
            newClasses.push(classes[i]);
          }
        }
        el.setAttribute('class', newClasses.join(' '));
      }
    }
  };
  
  dom.addEventListener = function addEventListener(el, type, handler) {
    if (utilities.isArray(el)) {
      utilities.forEach(el, function (e) {
        dom.addEventListener(e, type, handler);
      });
  
      return;
    }
  
    if (utilities.isArray(type)) {
      utilities.forEach(type, function (t) {
        dom.addEventListener(el, t, handler);
      });
  
      return;
    }
  
    if (el.addEventListener) {
      el.addEventListener(type, handler, false);
    } else if (el.attachEvent) {
      // WARNING!!! this is a very naive implementation !
      // the event object that should be passed to the handler
      // would not be there for IE8
      // we should use "window.event" and then "event.srcElement"
      // instead of "event.target"
      el.attachEvent('on' + type, handler);
    }
  };
  
  dom.removeEventListener = function removeEventListener(el, type, handler) {
    if (utilities.isArray(el)) {
      utilities.forEach(el, function (e) {
        dom.removeEventListener(e, type, handler);
      });
  
      return;
    }
  
    if (utilities.isArray(type)) {
      utilities.forEach(type, function (t) {
        dom.removeEventListener(el, t, handler);
      });
  
      return;
    }
  
    if (el.removeEventListener) {
      el.removeEventListener(type, handler, false);
    } else if (el.detachEvent) {
      el.detachEvent('on' + type, handler);
    } else {
      el['on' + type] = null;
    }
  };
  
  dom.dispatchEvent = function dispatchEvent(el, event) {
    if (el.dispatchEvent) {
      el.dispatchEvent(event);
    } else {
      el.fireEvent('on' + event.eventType, event);
    }
  };
  
  dom.isDescendant = function isDescendant(parent, child) {
    var node = child.parentNode;
  
    while (node !== null) {
      if (node === parent) {
        return true;
      }
      node = node.parentNode;
    }
  
    return false;
  };
  
  dom.getTextContent = function getTextContent(el) {
    return el.textContent || el.text;
  };
  
  dom.prependChild = function prependChild(parent, child) {
    if (child.parentNode) {
      child.parentNode.removeChild(child);
    }
  
    return parent.insertBefore(child, parent.firstChild);
  };
  
  dom.remove = function removeNode(node) {
    if (node && node.parentNode) {
      node.parentNode.removeChild(node);
    }
  };
  
  dom.isDomElement = function isDomElement(o) {
    return o instanceof Element;
  };
  
  dom.click = function (el, handler) {
    dom.addEventListener(el, 'click', handler);
  };
  
  dom.once = function (el, type, handler) {
    function handlerWrap() {
      handler.apply(undefined, arguments);
      dom.removeEventListener(el, type, handlerWrap);
    }
  
    dom.addEventListener(el, type, handlerWrap);
  };
  
  // Note: there is no getBoundingClientRect on iPad so we need a fallback
  dom.getDimension = function getDimension(element) {
    var rect = void 0;
  
    // On IE9 and below getBoundingClientRect does not work consistently
    if (!utilities.isOldIE() && element.getBoundingClientRect) {
      rect = element.getBoundingClientRect();
  
      return {
        width: rect.width,
        height: rect.height
      };
    }
  
    return {
      width: element.offsetWidth,
      height: element.offsetHeight
    };
  };
  
  module.exports = dom;
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var MultipleValuesRegistry = exports.MultipleValuesRegistry = function () {
      function MultipleValuesRegistry() {
          _classCallCheck(this, MultipleValuesRegistry);
  
          this._registries = {};
      }
  
      _createClass(MultipleValuesRegistry, [{
          key: 'add',
          value: function add(id, value) {
              if (!this._registries[id]) {
                  this._registries[id] = [];
              }
              if (this._registries[id].indexOf(value) === -1) {
                  this._registries[id].push(value);
              }
          }
      }, {
          key: 'get',
          value: function get(id) {
              return this._registries[id] || [];
          }
      }, {
          key: 'filterKeys',
          value: function filterKeys(handler) {
              return Object.keys(this._registries).filter(handler);
          }
      }, {
          key: 'findByValue',
          value: function findByValue(value) {
              var _this = this;
  
              var keys = Object.keys(this._registries).filter(function (key) {
                  return _this._registries[key].indexOf(value) !== -1;
              });
  
              return keys;
          }
      }, {
          key: 'remove',
          value: function remove(key, value) {
              if (!this._registries[key]) {
                  return;
              }
  
              var index = this._registries[key].indexOf(value);
  
              if (index < 0) {
                  return;
              }
              return this._registries[key].splice(index, 1);
          }
      }, {
          key: 'removeByKey',
          value: function removeByKey(id) {
              var old = this._registries[id];
              delete this._registries[id];
              return old;
          }
      }, {
          key: 'removeByValue',
          value: function removeByValue(value) {
              var _this2 = this;
  
              var keys = this.findByValue(value);
              return keys.map(function (key) {
                  return _this2.remove(key, value);
              });
          }
      }, {
          key: 'removeAll',
          value: function removeAll() {
              var old = this._registries;
              this._registries = {};
              return old;
          }
      }, {
          key: 'size',
          value: function size() {
              return Object.keys(this._registries).length;
          }
      }]);
  
      return MultipleValuesRegistry;
  }();
  
  var SingleValueRegistry = exports.SingleValueRegistry = function () {
      function SingleValueRegistry() {
          _classCallCheck(this, SingleValueRegistry);
  
          this._registries = {};
      }
  
      _createClass(SingleValueRegistry, [{
          key: 'add',
          value: function add(id, value) {
              this._registries[id] = value;
          }
      }, {
          key: 'get',
          value: function get(id) {
              return this._registries[id];
          }
      }, {
          key: 'filterKeys',
          value: function filterKeys(handler) {
              return Object.keys(this._registries).filter(handler);
          }
      }, {
          key: 'findByValue',
          value: function findByValue(value) {
              var _this3 = this;
  
              var keys = Object.keys(this._registries).filter(function (key) {
                  return _this3._registries[key] === value;
              });
  
              return keys;
          }
      }, {
          key: 'remove',
          value: function remove(id) {
              var old = this._registries[id];
              delete this._registries[id];
              return old;
          }
      }, {
          key: 'removeByValue',
          value: function removeByValue(value) {
              var _this4 = this;
  
              var keys = this.findByValue(value);
              return keys.map(function (key) {
                  return _this4.remove(key);
              });
          }
      }, {
          key: 'removeAll',
          value: function removeAll() {
              var old = this._registries;
              this._registries = {};
              return old;
          }
      }, {
          key: 'size',
          value: function size() {
              return Object.keys(this._registries).length;
          }
      }]);
  
      return SingleValueRegistry;
  }();
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var VideoClicks = __webpack_require__(21);
  var Linear = __webpack_require__(18);
  var InLine = __webpack_require__(17);
  var Ad = __webpack_require__(15);
  var Wrapper = __webpack_require__(22);
  
  window.InLine__A = InLine;
  function VASTResponse() {
    if (!(this instanceof VASTResponse)) {
      return new VASTResponse();
    }
  
    this._linearAdded = false;
    this.ads = [];
    this.errorURLMacros = [];
    this.impressions = [];
    this.clickTrackings = [];
    this.customClicks = [];
    this.trackingEvents = {};
    this.mediaFiles = [];
    this.clickThrough = undefined;
    this.adTitle = '';
    this.duration = undefined;
    this.skipoffset = undefined;
  }
  
  VASTResponse.prototype.addAd = function (ad) {
    var inLine = void 0,
        wrapper = void 0;
  
    if (ad instanceof Ad) {
      inLine = ad.inLine;
      wrapper = ad.wrapper;
  
      this.ads.push(ad);
  
      if (inLine) {
        this._addInLine(inLine);
      }
  
      if (wrapper) {
        this._addWrapper(wrapper);
      }
    }
  };
  
  VASTResponse.prototype._addErrorTrackUrl = function (error) {
    var errorURL = error instanceof xml.JXONTree ? xml.keyValue(error) : error;
  
    if (errorURL) {
      this.errorURLMacros.push(errorURL);
    }
  };
  
  VASTResponse.prototype._addImpressions = function (impressions) {
    if (Array.isArray(impressions)) {
      appendToArray(this.impressions, impressions);
    }
  };
  
  VASTResponse.prototype._addClickThrough = function (clickThrough) {
    if (utilities.isNotEmptyString(clickThrough)) {
      this.clickThrough = clickThrough;
    }
  };
  
  VASTResponse.prototype._addClickTrackings = function (clickTrackings) {
    if (Array.isArray(clickTrackings)) {
      appendToArray(this.clickTrackings, clickTrackings);
    }
  };
  
  VASTResponse.prototype._addCustomClicks = function (customClicks) {
    if (Array.isArray(customClicks)) {
      appendToArray(this.customClicks, customClicks);
    }
  };
  
  VASTResponse.prototype._addTrackingEvents = function (trackingEvents) {
    var eventsMap = this.trackingEvents;
  
    if (trackingEvents) {
      trackingEvents = utilities.isArray(trackingEvents) ? trackingEvents : [trackingEvents];
      trackingEvents.forEach(function (trackingEvent) {
        if (!eventsMap[trackingEvent.name]) {
          eventsMap[trackingEvent.name] = [];
        }
        eventsMap[trackingEvent.name].push(trackingEvent);
      });
    }
  };
  
  VASTResponse.prototype._addTitle = function (title) {
    if (utilities.isNotEmptyString(title)) {
      this.adTitle = title;
    }
  };
  
  VASTResponse.prototype._addDuration = function (duration) {
    if (utilities.isNumber(duration)) {
      this.duration = duration;
    }
  };
  
  VASTResponse.prototype._addVideoClicks = function (videoClicks) {
    if (videoClicks instanceof VideoClicks) {
      this._addClickThrough(videoClicks.clickThrough);
      this._addClickTrackings(videoClicks.clickTrackings);
      this._addCustomClicks(videoClicks.customClicks);
    }
  };
  
  VASTResponse.prototype._addMediaFiles = function (mediaFiles) {
    if (Array.isArray(mediaFiles)) {
      appendToArray(this.mediaFiles, mediaFiles);
    }
  };
  
  VASTResponse.prototype._addSkipoffset = function (offset) {
    if (offset) {
      this.skipoffset = offset;
    }
  };
  
  VASTResponse.prototype._addAdParameters = function (adParameters) {
    if (adParameters) {
      this.adParameters = adParameters;
    }
  };
  
  VASTResponse.prototype._addLinear = function (linear) {
    if (linear instanceof Linear) {
      this._addDuration(linear.duration);
      this._addTrackingEvents(linear.trackingEvents);
      this._addVideoClicks(linear.videoClicks);
      this._addMediaFiles(linear.mediaFiles);
      this._addSkipoffset(linear.skipoffset);
      this._addAdParameters(linear.adParameters);
      this._linearAdded = true;
    }
  };
  
  VASTResponse.prototype._addInLine = function (inLine) {
    var that = this;
  
    if (inLine instanceof InLine) {
      this._addTitle(inLine.adTitle);
      this._addErrorTrackUrl(inLine.error);
      this._addImpressions(inLine.impressions);
  
      inLine.creatives.forEach(function (creative) {
        if (creative.linear) {
          that._addLinear(creative.linear);
        }
      });
    }
  };
  
  VASTResponse.prototype._addWrapper = function (wrapper) {
    var that = this;
  
    if (wrapper instanceof Wrapper) {
      this._addErrorTrackUrl(wrapper.error);
      this._addImpressions(wrapper.impressions);
  
      wrapper.creatives.forEach(function (creative) {
        var linear = creative.linear;
  
        if (linear) {
          that._addVideoClicks(linear.videoClicks);
          that.clickThrough = undefined; // We ensure that no clickThrough has been added
          that._addTrackingEvents(linear.trackingEvents);
        }
      });
    }
  };
  
  VASTResponse.prototype.hasLinear = function () {
    return this._linearAdded;
  };
  
  function appendToArray(array, items) {
    items.forEach(function (item) {
      array.push(item);
    });
  }
  
  module.exports = VASTResponse;
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
  
  // Small subset of async
  
  var utilities = __webpack_require__(0);
  
  var async = {};
  
  async.setImmediate = function (fn) {
    setTimeout(fn, 0);
  };
  
  async.iterator = function (tasks) {
    var makeCallback = function makeCallback(index) {
      var fn = function fn() {
        if (tasks.length) {
          tasks[index].apply(null, arguments);
        }
  
        return fn.next();
      };
  
      fn.next = function () {
        return index < tasks.length - 1 ? makeCallback(index + 1) : null;
      };
  
      return fn;
    };
  
    return makeCallback(0);
  };
  
  async.waterfall = function (tasks, callback) {
    callback = callback || function () {};
    if (!utilities.isArray(tasks)) {
      var err = new Error('First argument to waterfall must be an array of functions');
  
      return callback(err);
    }
    if (!tasks.length) {
      return callback();
    }
    var wrapIterator = function wrapIterator(iterator) {
      return function (err) {
        if (err) {
          callback.apply(undefined, arguments);
          callback = function callback() {};
        } else {
          var args = Array.prototype.slice.call(arguments, 1);
          var next = iterator.next();
  
          if (next) {
            args.push(wrapIterator(next));
          } else {
            args.push(callback);
          }
          async.setImmediate(function () {
            iterator.apply(undefined, _toConsumableArray(args));
          });
        }
      };
    };
  
    wrapIterator(async.iterator(tasks))();
  };
  
  async.when = function (condition, callback) {
    if (!utilities.isFunction(callback)) {
      throw new Error('async.when error: missing callback argument');
    }
  
    var isAllowed = utilities.isFunction(condition) ? condition : function () {
      return Boolean(condition);
    };
  
    return function () {
      var args = utilities.arrayLikeObjToArray(arguments);
      var next = args.pop();
  
      if (isAllowed.apply(undefined, _toConsumableArray(args))) {
        return callback.apply(this, arguments);
      }
  
      args.unshift(null);
  
      return next.apply(undefined, _toConsumableArray(args));
    };
  };
  
  module.exports = async;
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  module.exports = {
    html5: ['text/javascript', 'text/javascript1.0', 'text/javascript1.2', 'text/javascript1.4', 'text/jscript', 'application/javascript', 'application/x-javascript', 'text/ecmascript', 'text/ecmascript1.0', 'text/ecmascript1.2', 'text/ecmascript1.4', 'text/livescript', 'application/ecmascript', 'application/x-ecmascript'],
  
    flash: ['application/x-shockwave-flash']
  };
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var dom = __webpack_require__(6);
  var utilities = __webpack_require__(0);
  
  var playerUtils = {};
  
  /**
   * Returns an object that captures the portions of player state relevant to
   * video playback. The result of this function can be passed to
   * restorePlayerSnapshot with a player to return the player to the state it
   * was in when this function was invoked.
   * @param {object} player The videojs player object
   */
  playerUtils.getPlayerSnapshot = function getPlayerSnapshot(player) {
    var tech = player.el().querySelector('.vjs-tech');
  
    var snapshot = {
      ended: player.ended(),
      src: player.currentSrc(),
      currentTime: player.currentTime(),
      type: player.currentType(),
      playing: !player.paused(),
      suppressedTracks: getSuppressedTracks(player)
    };
  
    if (tech) {
      snapshot.nativePoster = tech.poster;
      snapshot.style = tech.getAttribute('style');
    }
  
    return snapshot;
  
    /** ** Local Functions ****/
    function getSuppressedTracks(player) {
      var tracks = player.remoteTextTracks ? player.remoteTextTracks() : [];
  
      if (tracks && utilities.isArray(tracks.tracks)) {
        tracks = tracks.tracks;
      }
  
      if (!utilities.isArray(tracks)) {
        tracks = [];
      }
  
      var suppressedTracks = [];
  
      tracks.forEach(function (track) {
        suppressedTracks.push({
          track: track,
          mode: track.mode
        });
        track.mode = 'disabled';
      });
  
      return suppressedTracks;
    }
  };
  
  /**
   * Attempts to modify the specified player so that its state is equivalent to
   * the state of the snapshot.
   * @param {object} snapshot - the player state to apply
   */
  playerUtils.restorePlayerSnapshot = function restorePlayerSnapshot(player, snapshot) {
    var tech = player.el().querySelector('.vjs-tech');
    var attempts = 20; // the number of remaining attempts to restore the snapshot
  
    if (snapshot.nativePoster) {
      tech.poster = snapshot.nativePoster;
    }
  
    if ('style' in snapshot) {
      // overwrite all css style properties to restore state precisely
      tech.setAttribute('style', snapshot.style || '');
    }
  
    if (hasSrcChanged(player, snapshot)) {
      // on ios7, fiddling with textTracks too early will cause safari to crash
      player.one('contentloadedmetadata', restoreTracks);
  
      player.one('canplay', tryToResume);
      ensureCanplayEvtGetsFired();
  
      // if the src changed for ad playback, reset it
      player.src({ src: snapshot.src, type: snapshot.type });
  
      // safari requires a call to `load` to pick up a changed source
      player.load();
    } else {
      restoreTracks();
  
      if (snapshot.playing) {
        player.play();
      }
    }
  
    /** * Local Functions ***/
  
    /**
     * Sometimes firefox does not trigger the 'canplay' evt.
     * This code ensure that it always gets triggered triggered.
     */
    function ensureCanplayEvtGetsFired() {
      var timeoutId = setTimeout(function () {
        player.trigger('canplay');
      }, 1000);
  
      player.one('canplay', function () {
        clearTimeout(timeoutId);
      });
    }
  
    /**
     * Determine whether the player needs to be restored to its state
     * before ad playback began. With a custom ad display or burned-in
     * ads, the content player state hasn't been modified and so no
     * restoration is required
     */
    function hasSrcChanged(player, snapshot) {
      if (player.src()) {
        return player.src() !== snapshot.src;
      }
  
      // the player was configured through source element children
      return player.currentSrc() !== snapshot.src;
    }
  
    function restoreTracks() {
      var suppressedTracks = snapshot.suppressedTracks;
  
      suppressedTracks.forEach(function (trackSnapshot) {
        trackSnapshot.track.mode = trackSnapshot.mode;
      });
    }
  
    /**
     * Determine if the video element has loaded enough of the snapshot source
     * to be ready to apply the rest of the state
     */
    function tryToResume() {
      // if some period of the video is seekable, resume playback
      // otherwise delay a bit and then check again unless we're out of attempts
  
      if (!playerUtils.isReadyToResume(player) && attempts--) {
        setTimeout(tryToResume, 50);
      } else {
        try {
          if (player.currentTime() !== snapshot.currentTime) {
            if (snapshot.playing) {
              // if needed restore playing status after seek completes
              player.one('seeked', function () {
                player.play();
              });
            }
            player.currentTime(snapshot.currentTime);
          } else if (snapshot.playing) {
            // if needed and no seek has been performed, restore playing status immediately
            player.play();
          }
        } catch (e) {
          videojs.log.warn('Failed to resume the content after an advertisement', e);
        }
      }
    }
  };
  
  playerUtils.isReadyToResume = function (player) {
    if (player.readyState() > 1) {
      // some browsers and media aren't "seekable".
      // readyState greater than 1 allows for seeking without exceptions
      return true;
    }
  
    if (player.seekable() === undefined) {
      // if the player doesn't expose the seekable time ranges, try to
      // resume playback immediately
      return true;
    }
  
    if (player.seekable().length > 0) {
      // if some period of the video is seekable, resume playback
      return true;
    }
  
    return false;
  };
  
  /**
   * This function prepares the player to display ads.
   * Adding convenience events like the 'vast.firsPlay' that gets fired when the video is first played
   * and ads the blackPoster to the player to prevent content from being displayed before the preroll ad.
   *
   * @param player
   */
  playerUtils.prepareForAds = function (player) {
    var blackPoster = player.addChild('blackPoster');
    var _firstPlay = true;
    var _firstPlayInProgress = false;
    var volumeSnapshot = void 0;
  
    monkeyPatchPlayerApi();
  
    player.on('play', tryToTriggerFirstPlay);
    player.on('vast.reset', resetFirstPlay); // Every time we change the sources we reset the first play.
    player.on('vast.firstPlay', restoreContentVolume);
    player.on('error', hideBlackPoster); // If there is an error in the player we remove the blackposter to show the err msg
    player.on('vast.adStart', hideBlackPoster);
    player.on('vast.adsCancel', hideBlackPoster);
    player.on('vast.adError', hideBlackPoster);
    player.on('vast.adStart', addStyles);
    player.on('vast.adEnd', removeStyles);
    player.on('vast.adsCancel', removeStyles);
  
    /** * Local Functions ***/
  
    /**
     What this function does is ugly and horrible and I should think twice before calling myself a good developer. With that said,
     it is the best solution I could find to mute the video until the 'play' event happens (on mobile devices) and the plugin can decide whether
     to play the ad or not.
      We also need this monkeypatch to be able to pause and resume an ad using the player's API
      If you have a better solution please do tell me.
     */
    function monkeyPatchPlayerApi() {
      /**
       * Monkey patch needed to handle firstPlay and resume of playing ad.
       *
       * @param callOrigPlay necessary flag to prevent infinite loop when you are restoring a VAST ad.
       * @returns {player}
       */
      var origPlay = player.play;
  
      player.play = function (callOrigPlay) {
        var that = this;
  
        if (isFirstPlay()) {
          firstPlay();
        } else {
          resume(callOrigPlay);
        }
  
        return this;
  
        /** * local functions ***/
        function firstPlay() {
          if (_firstPlayInProgress) {
            return;
          }
  
          _firstPlayInProgress = true;
          if (!utilities.isIPhone()) {
            volumeSnapshot = saveVolumeSnapshot();
            player.muted(true);
          }
  
          origPlay.apply(that, arguments);
        }
  
        function resume(callOrigPlay) {
          if (isAdPlaying() && !callOrigPlay) {
            player.vast.adUnit.resumeAd();
          } else {
            origPlay.apply(that, arguments);
          }
        }
      };
  
      /**
       * Needed monkey patch to handle pause of playing ad.
       *
       * @param callOrigPlay necessary flag to prevent infinite loop when you are pausing a VAST ad.
       * @returns {player}
       */
      var origPause = player.pause;
  
      player.pause = function (callOrigPause) {
        if (isAdPlaying() && !callOrigPause) {
          player.vast.adUnit.pauseAd();
        } else {
          origPause.apply(this, arguments);
        }
  
        return this;
      };
  
      /**
       * Needed monkey patch to handle paused state of the player when ads are playing.
       *
       * @param callOrigPlay necessary flag to prevent infinite loop when you are pausing a VAST ad.
       * @returns {player}
       */
      var origPaused = player.paused;
  
      player.paused = function (callOrigPaused) {
        if (isAdPlaying() && !callOrigPaused) {
          return player.vast.adUnit.isPaused();
        }
  
        return origPaused.apply(this, arguments);
      };
    }
  
    function isAdPlaying() {
      return player.vast && player.vast.adUnit;
    }
  
    function tryToTriggerFirstPlay() {
      if (isFirstPlay()) {
        _firstPlay = false;
        _firstPlayInProgress = false;
        player.trigger('vast.firstPlay');
      }
    }
  
    function resetFirstPlay() {
      _firstPlay = true;
      blackPoster.show();
      restoreContentVolume();
    }
  
    function isFirstPlay() {
      return _firstPlay;
    }
  
    function saveVolumeSnapshot() {
      return {
        muted: player.muted(),
        volume: player.volume()
      };
    }
  
    function restoreContentVolume() {
      if (volumeSnapshot) {
        player.currentTime(0);
        restoreVolumeSnapshot(volumeSnapshot);
        volumeSnapshot = null;
      }
    }
  
    function restoreVolumeSnapshot(snapshot) {
      if (utilities.isObject(snapshot)) {
        player.volume(snapshot.volume);
        player.muted(snapshot.muted);
      }
    }
  
    function hideBlackPoster() {
      if (!dom.hasClass(blackPoster.el(), 'vjs-hidden')) {
        blackPoster.hide();
      }
    }
  
    function addStyles() {
      dom.addClass(player.el(), 'vjs-ad-playing');
    }
  
    function removeStyles() {
      dom.removeClass(player.el(), 'vjs-ad-playing');
    }
  };
  
  /**
   * Remove the poster attribute from the video element tech, if present. When
   * reusing a video element for multiple videos, the poster image will briefly
   * reappear while the new source loads. Removing the attribute ahead of time
   * prevents the poster from showing up between videos.
   * @param {object} player The videojs player object
   */
  playerUtils.removeNativePoster = function (player) {
    var tech = player.el().querySelector('.vjs-tech');
  
    if (tech) {
      tech.removeAttribute('poster');
    }
  };
  
  /**
   * Helper function to listen to many events until one of them gets fired, then we
   * execute the handler and unsubscribe all the event listeners;
   *
   * @param player specific player from where to listen for the events
   * @param events array of events
   * @param handler function to execute once one of the events fires
   */
  playerUtils.once = function once(player, events, handler) {
    function listener() {
      handler.apply(undefined, arguments);
  
      events.forEach(function (event) {
        player.off(event, listener);
      });
    }
  
    events.forEach(function (event) {
      player.on(event, listener);
    });
  };
  
  module.exports = playerUtils;
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var swfobject = __webpack_require__(25);
  
  var JSFlashBridge = __webpack_require__(13).JSFlashBridge;
  var VPAIDAdUnit = __webpack_require__(29).VPAIDAdUnit;
  
  var noop = __webpack_require__(1).noop;
  var callbackTimeout = __webpack_require__(1).callbackTimeout;
  var isPositiveInt = __webpack_require__(1).isPositiveInt;
  var createElementWithID = __webpack_require__(1).createElementWithID;
  var uniqueVPAID = __webpack_require__(1).unique('vpaid');
  var createFlashTester = __webpack_require__(30).createFlashTester;
  
  var ERROR = 'error';
  var FLASH_VERSION = '10.1.0';
  
  var flashTester = { isSupported: function isSupported() {
          return true;
      } }; // if the runFlashTest is not run the flashTester will always return true
  
  var VPAIDFLASHClient = function () {
      function VPAIDFLASHClient(vpaidParentEl, callback) {
          var swfConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : { data: 'VPAIDFlash.swf', width: 800, height: 400 };
  
          var _this = this;
  
          var params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : { wmode: 'transparent', salign: 'tl', align: 'left', allowScriptAccess: 'always', scale: 'noScale', allowFullScreen: 'true', quality: 'high' };
          var vpaidOptions = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : { debug: false, timeout: 10000 };
  
          _classCallCheck(this, VPAIDFLASHClient);
  
          var me = this;
  
          this._vpaidParentEl = vpaidParentEl;
          this._flashID = uniqueVPAID();
          this._destroyed = false;
          callback = callback || noop;
  
          swfConfig.width = isPositiveInt(swfConfig.width, 800);
          swfConfig.height = isPositiveInt(swfConfig.height, 400);
  
          createElementWithID(vpaidParentEl, this._flashID, true);
  
          params.movie = swfConfig.data;
          params.FlashVars = 'flashid=' + this._flashID + '&handler=' + JSFlashBridge.VPAID_FLASH_HANDLER + '&debug=' + vpaidOptions.debug + '&salign=' + params.salign;
  
          if (!VPAIDFLASHClient.isSupported()) {
              return onError('user don\'t support flash or doesn\'t have the minimum required version of flash ' + FLASH_VERSION);
          }
  
          this.el = swfobject.createSWF(swfConfig, params, this._flashID);
  
          if (!this.el) {
              return onError('swfobject failed to create object in element');
          }
  
          var handler = callbackTimeout(vpaidOptions.timeout, function (err, data) {
              $loadPendedAdUnit.call(_this);
              callback(err, data);
          }, function () {
              callback('vpaid flash load timeout ' + vpaidOptions.timeout);
          });
  
          this._flash = new JSFlashBridge(this.el, swfConfig.data, this._flashID, swfConfig.width, swfConfig.height, handler);
  
          function onError(error) {
              setTimeout(function () {
                  callback(new Error(error));
              }, 0);
              return me;
          }
      }
  
      _createClass(VPAIDFLASHClient, [{
          key: 'destroy',
          value: function destroy() {
              this._destroyAdUnit();
  
              if (this._flash) {
                  this._flash.destroy();
                  this._flash = null;
              }
              this.el = null;
              this._destroyed = true;
          }
      }, {
          key: 'isDestroyed',
          value: function isDestroyed() {
              return this._destroyed;
          }
      }, {
          key: '_destroyAdUnit',
          value: function _destroyAdUnit() {
              delete this._loadLater;
  
              if (this._adUnitLoad) {
                  this._adUnitLoad = null;
                  this._flash.removeCallback(this._adUnitLoad);
              }
  
              if (this._adUnit) {
                  this._adUnit._destroy();
                  this._adUnit = null;
              }
          }
      }, {
          key: 'loadAdUnit',
          value: function loadAdUnit(adURL, callback) {
              var _this2 = this;
  
              $throwIfDestroyed.call(this);
  
              if (this._adUnit) {
                  this._destroyAdUnit();
              }
  
              if (this._flash.isReady()) {
                  this._adUnitLoad = function (err, message) {
                      if (!err) {
                          _this2._adUnit = new VPAIDAdUnit(_this2._flash);
                      }
                      _this2._adUnitLoad = null;
                      callback(err, _this2._adUnit);
                  };
  
                  this._flash.callFlashMethod('loadAdUnit', [adURL], this._adUnitLoad);
              } else {
                  this._loadLater = { url: adURL, callback: callback };
              }
          }
      }, {
          key: 'unloadAdUnit',
          value: function unloadAdUnit() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              $throwIfDestroyed.call(this);
  
              this._destroyAdUnit();
              this._flash.callFlashMethod('unloadAdUnit', [], callback);
          }
      }, {
          key: 'getFlashID',
          value: function getFlashID() {
              $throwIfDestroyed.call(this);
              return this._flash.getFlashID();
          }
      }, {
          key: 'getFlashURL',
          value: function getFlashURL() {
              $throwIfDestroyed.call(this);
              return this._flash.getFlashURL();
          }
      }]);
  
      return VPAIDFLASHClient;
  }();
  
  setStaticProperty('isSupported', function () {
      return swfobject.hasFlashPlayerVersion(FLASH_VERSION) && flashTester.isSupported();
  }, true);
  
  setStaticProperty('runFlashTest', function (swfConfig) {
      flashTester = createFlashTester(document.body, swfConfig);
  });
  
  function $throwIfDestroyed() {
      if (this._destroyed) {
          throw new Error('VPAIDFlashToJS is destroyed!');
      }
  }
  
  function $loadPendedAdUnit() {
      if (this._loadLater) {
          this.loadAdUnit(this._loadLater.url, this._loadLater.callback);
          delete this._loadLater;
      }
  }
  
  function setStaticProperty(propertyName, value) {
      var writable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  
      Object.defineProperty(VPAIDFLASHClient, propertyName, {
          writable: writable,
          configurable: false,
          value: value
      });
  }
  
  VPAIDFLASHClient.swfobject = swfobject;
  
  module.exports = VPAIDFLASHClient;
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var unique = __webpack_require__(1).unique;
  var isPositiveInt = __webpack_require__(1).isPositiveInt;
  var stringEndsWith = __webpack_require__(1).stringEndsWith;
  var SingleValueRegistry = __webpack_require__(7).SingleValueRegistry;
  var MultipleValuesRegistry = __webpack_require__(7).MultipleValuesRegistry;
  var registry = __webpack_require__(31);
  var VPAID_FLASH_HANDLER = 'vpaid_video_flash_handler';
  var ERROR = 'AdError';
  
  var JSFlashBridge = exports.JSFlashBridge = function () {
      function JSFlashBridge(el, flashURL, flashID, width, height, loadHandShake) {
          _classCallCheck(this, JSFlashBridge);
  
          this._el = el;
          this._flashID = flashID;
          this._flashURL = flashURL;
          this._width = width;
          this._height = height;
          this._handlers = new MultipleValuesRegistry();
          this._callbacks = new SingleValueRegistry();
          this._uniqueMethodIdentifier = unique(this._flashID);
          this._ready = false;
          this._handShakeHandler = loadHandShake;
  
          registry.addInstance(this._flashID, this);
      }
  
      _createClass(JSFlashBridge, [{
          key: 'on',
          value: function on(eventName, callback) {
              this._handlers.add(eventName, callback);
          }
      }, {
          key: 'off',
          value: function off(eventName, callback) {
              return this._handlers.remove(eventName, callback);
          }
      }, {
          key: 'offEvent',
          value: function offEvent(eventName) {
              return this._handlers.removeByKey(eventName);
          }
      }, {
          key: 'offAll',
          value: function offAll() {
              return this._handlers.removeAll();
          }
      }, {
          key: 'callFlashMethod',
          value: function callFlashMethod(methodName) {
              var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
              var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
  
              var callbackID = '';
              // if no callback, some methods the return is void so they don't need callback
              if (callback) {
                  callbackID = this._uniqueMethodIdentifier() + '_' + methodName;
                  this._callbacks.add(callbackID, callback);
              }
  
              try {
                  //methods are created by ExternalInterface.addCallback in as3 code, if for some reason it failed
                  //this code will throw an error
                  this._el[methodName]([callbackID].concat(args));
              } catch (e) {
                  if (callback) {
                      $asyncCallback.call(this, callbackID, e);
                  } else {
  
                      //if there isn't any callback to return error use error event handler
                      this._trigger(ERROR, e);
                  }
              }
          }
      }, {
          key: 'removeCallback',
          value: function removeCallback(callback) {
              return this._callbacks.removeByValue(callback);
          }
      }, {
          key: 'removeCallbackByMethodName',
          value: function removeCallbackByMethodName(suffix) {
              var _this = this;
  
              this._callbacks.filterKeys(function (key) {
                  return stringEndsWith(key, suffix);
              }).forEach(function (key) {
                  _this._callbacks.remove(key);
              });
          }
      }, {
          key: 'removeAllCallbacks',
          value: function removeAllCallbacks() {
              return this._callbacks.removeAll();
          }
      }, {
          key: '_trigger',
          value: function _trigger(eventName, event) {
              var _this2 = this;
  
              this._handlers.get(eventName).forEach(function (callback) {
                  //clickThru has to be sync, if not will be block by the popupblocker
                  if (eventName === 'AdClickThru') {
                      callback(event);
                  } else {
                      setTimeout(function () {
                          if (_this2._handlers.get(eventName).length > 0) {
                              callback(event);
                          }
                      }, 0);
                  }
              });
          }
      }, {
          key: '_callCallback',
          value: function _callCallback(methodName, callbackID, err, result) {
  
              var callback = this._callbacks.get(callbackID);
  
              //not all methods callback's are mandatory
              //but if there exist an error, fire the error event
              if (!callback) {
                  if (err && callbackID === '') {
                      this.trigger(ERROR, err);
                  }
                  return;
              }
  
              $asyncCallback.call(this, callbackID, err, result);
          }
      }, {
          key: '_handShake',
          value: function _handShake(err, data) {
              this._ready = true;
              if (this._handShakeHandler) {
                  this._handShakeHandler(err, data);
                  delete this._handShakeHandler;
              }
          }
  
          //methods like properties specific to this implementation of VPAID
  
      }, {
          key: 'getSize',
          value: function getSize() {
              return { width: this._width, height: this._height };
          }
      }, {
          key: 'setSize',
          value: function setSize(newWidth, newHeight) {
              this._width = isPositiveInt(newWidth, this._width);
              this._height = isPositiveInt(newHeight, this._height);
              this._el.setAttribute('width', this._width);
              this._el.setAttribute('height', this._height);
          }
      }, {
          key: 'getWidth',
          value: function getWidth() {
              return this._width;
          }
      }, {
          key: 'setWidth',
          value: function setWidth(newWidth) {
              this.setSize(newWidth, this._height);
          }
      }, {
          key: 'getHeight',
          value: function getHeight() {
              return this._height;
          }
      }, {
          key: 'setHeight',
          value: function setHeight(newHeight) {
              this.setSize(this._width, newHeight);
          }
      }, {
          key: 'getFlashID',
          value: function getFlashID() {
              return this._flashID;
          }
      }, {
          key: 'getFlashURL',
          value: function getFlashURL() {
              return this._flashURL;
          }
      }, {
          key: 'isReady',
          value: function isReady() {
              return this._ready;
          }
      }, {
          key: 'destroy',
          value: function destroy() {
              this.offAll();
              this.removeAllCallbacks();
              registry.removeInstanceByID(this._flashID);
              if (this._el.parentElement) {
                  this._el.parentElement.removeChild(this._el);
              }
          }
      }]);
  
      return JSFlashBridge;
  }();
  
  function $asyncCallback(callbackID, err, result) {
      var _this3 = this;
  
      setTimeout(function () {
          var callback = _this3._callbacks.get(callbackID);
          if (callback) {
              _this3._callbacks.remove(callbackID);
              callback(err, result);
          }
      }, 0);
  }
  
  Object.defineProperty(JSFlashBridge, 'VPAID_FLASH_HANDLER', {
      writable: false,
      configurable: false,
      value: VPAID_FLASH_HANDLER
  });
  
  /**
   * External interface handler
   *
   * @param {string} flashID identifier of the flash who call this
   * @param {string} typeID what type of message is, can be 'event' or 'callback'
   * @param {string} typeName if the typeID is a event the typeName will be the eventName, if is a callback the typeID is the methodName that is related this callback
   * @param {string} callbackID only applies when the typeID is 'callback', identifier of the callback to call
   * @param {object} error error object
   * @param {object} data
   */
  window[VPAID_FLASH_HANDLER] = function (flashID, typeID, typeName, callbackID, error, data) {
      var instance = registry.getInstanceByID(flashID);
      if (!instance) return;
      if (typeName === 'handShake') {
          instance._handShake(error, data);
      } else {
          if (typeID !== 'event') {
              instance._callCallback(typeName, callbackID, error, data);
          } else {
              instance._trigger(typeName, data);
          }
      }
  };
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * noop a empty function
   */
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  function noop() {}
  
  /**
   * validate if is not validate will return an Error with the message
   *
   * @param {boolean} isValid
   * @param {string} message
   */
  function validate(isValid, message) {
      return isValid ? null : new Error(message);
  }
  
  var timeouts = {};
  /**
   * clearCallbackTimeout
   *
   * @param {function} func handler to remove
   */
  function clearCallbackTimeout(func) {
      var timeout = timeouts[func];
      if (timeout) {
          clearTimeout(timeout);
          delete timeouts[func];
      }
  }
  
  /**
   * callbackTimeout if the onSuccess is not called and returns true in the timelimit then onTimeout will be called
   *
   * @param {number} timer
   * @param {function} onSuccess
   * @param {function} onTimeout
   */
  function callbackTimeout(timer, onSuccess, onTimeout) {
      var _callback, timeout;
  
      timeout = setTimeout(function () {
          onSuccess = noop;
          delete timeout[_callback];
          onTimeout();
      }, timer);
  
      _callback = function callback() {
          // TODO avoid leaking arguments
          // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
          if (onSuccess.apply(this, arguments)) {
              clearCallbackTimeout(_callback);
          }
      };
  
      timeouts[_callback] = timeout;
  
      return _callback;
  }
  
  /**
   * createElementInEl
   *
   * @param {HTMLElement} parent
   * @param {string} tagName
   * @param {string} id
   */
  function createElementInEl(parent, tagName, id) {
      var nEl = document.createElement(tagName);
      if (id) nEl.id = id;
      parent.appendChild(nEl);
      return nEl;
  }
  
  /**
   * createIframeWithContent
   *
   * @param {HTMLElement} parent
   * @param {string} template simple template using {{var}}
   * @param {object} data
   */
  function createIframeWithContent(parent, template, data) {
      var iframe = createIframe(parent, null, data.zIndex);
      if (!setIframeContent(iframe, simpleTemplate(template, data))) return;
      return iframe;
  }
  
  /**
   * createIframe
   *
   * @param {HTMLElement} parent
   * @param {string} url
   */
  function createIframe(parent, url, zIndex) {
      var nEl = document.createElement('iframe');
      nEl.src = url || 'about:blank';
      nEl.marginWidth = '0';
      nEl.marginHeight = '0';
      nEl.frameBorder = '0';
      nEl.width = '100%';
      nEl.height = '100%';
      setFullSizeStyle(nEl);
  
      if (zIndex) {
          nEl.style.zIndex = zIndex;
      }
  
      nEl.setAttribute('SCROLLING', 'NO');
      parent.innerHTML = '';
      parent.appendChild(nEl);
      return nEl;
  }
  
  function setFullSizeStyle(element) {
      element.style.position = 'absolute';
      element.style.left = '0';
      element.style.top = '0';
      element.style.margin = '0px';
      element.style.padding = '0px';
      element.style.border = 'none';
      element.style.width = '100%';
      element.style.height = '100%';
  }
  
  /**
   * simpleTemplate
   *
   * @param {string} template
   * @param {object} data
   */
  function simpleTemplate(template, data) {
      Object.keys(data).forEach(function (key) {
          var value = (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' ? JSON.stringify(data[key]) : data[key];
          template = template.replace(new RegExp('{{' + key + '}}', 'g'), value);
      });
      return template;
  }
  
  /**
   * setIframeContent
   *
   * @param {HTMLIframeElement} iframeEl
   * @param content
   */
  function setIframeContent(iframeEl, content) {
      var iframeDoc = iframeEl.contentWindow && iframeEl.contentWindow.document;
      if (!iframeDoc) return false;
  
      iframeDoc.write(content);
  
      return true;
  }
  
  /**
   * extend object with keys from another object
   *
   * @param {object} toExtend
   * @param {object} fromSource
   */
  function extend(toExtend, fromSource) {
      Object.keys(fromSource).forEach(function (key) {
          toExtend[key] = fromSource[key];
      });
      return toExtend;
  }
  
  /**
   * unique will create a unique string everytime is called, sequentially and prefixed
   *
   * @param {string} prefix
   */
  function unique(prefix) {
      var count = -1;
      return function () {
          return prefix + '_' + ++count;
      };
  }
  
  module.exports = {
      noop: noop,
      validate: validate,
      clearCallbackTimeout: clearCallbackTimeout,
      callbackTimeout: callbackTimeout,
      createElementInEl: createElementInEl,
      createIframeWithContent: createIframeWithContent,
      createIframe: createIframe,
      setFullSizeStyle: setFullSizeStyle,
      simpleTemplate: simpleTemplate,
      setIframeContent: setIframeContent,
      extend: extend,
      unique: unique
  };
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var InLine = __webpack_require__(17);
  var Wrapper = __webpack_require__(22);
  
  function Ad(adJTree) {
    if (!(this instanceof Ad)) {
      return new Ad(adJTree);
    }
    this.initialize(adJTree);
  }
  
  Ad.prototype.initialize = function (adJTree) {
    this.id = adJTree.attr('id');
    this.sequence = adJTree.attr('sequence');
  
    if (adJTree.inLine) {
      this.inLine = new InLine(adJTree.inLine);
    }
  
    if (adJTree.wrapper) {
      this.wrapper = new Wrapper(adJTree.wrapper);
    }
  };
  
  module.exports = Ad;
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var Companion = __webpack_require__(36);
  var Linear = __webpack_require__(18);
  
  function Creative(creativeJTree) {
    if (!(this instanceof Creative)) {
      return new Creative(creativeJTree);
    }
  
    this.id = creativeJTree.attr('id');
    this.sequence = creativeJTree.attr('sequence');
    this.adId = creativeJTree.attr('adId');
    this.apiFramework = creativeJTree.attr('apiFramework');
  
    if (creativeJTree.linear) {
      this.linear = new Linear(creativeJTree.linear);
    }
  
    if (creativeJTree.companionAds) {
      var companions = [];
      var companionAds = creativeJTree.companionAds && creativeJTree.companionAds.companion;
  
      if (utilities.isDefined(companionAds)) {
        companionAds = utilities.isArray(companionAds) ? companionAds : [companionAds];
        companionAds.forEach(function (companionData) {
          companions.push(new Companion(companionData));
        });
      }
      this.companionAds = companions;
    }
  }
  
  /**
   * Returns true if the browser supports at the creative.
   */
  Creative.prototype.isSupported = function () {
    if (this.linear) {
      return this.linear.isSupported();
    }
  
    return true;
  };
  
  Creative.parseCreatives = function parseCreatives(creativesJTree) {
    var creatives = [];
    var creativesData = void 0;
  
    if (utilities.isDefined(creativesJTree) && utilities.isDefined(creativesJTree.creative)) {
      creativesData = utilities.isArray(creativesJTree.creative) ? creativesJTree.creative : [creativesJTree.creative];
      creativesData.forEach(function (creative) {
        creatives.push(new Creative(creative));
      });
    }
  
    return creatives;
  };
  
  module.exports = Creative;
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var vastUtil = __webpack_require__(4);
  var Creative = __webpack_require__(16);
  
  function InLine(inlineJTree) {
    if (!(this instanceof InLine)) {
      return new InLine(inlineJTree);
    }
  
    // Required Fields
    this.adTitle = xml.keyValue(inlineJTree.adTitle);
    this.adSystem = xml.keyValue(inlineJTree.adSystem);
    this.impressions = vastUtil.parseImpressions(inlineJTree.impression);
    this.creatives = Creative.parseCreatives(inlineJTree.creatives);
  
    // Optional Fields
    this.description = xml.keyValue(inlineJTree.description);
    this.advertiser = xml.keyValue(inlineJTree.advertiser);
    this.surveys = parseSurveys(inlineJTree.survey);
    this.error = xml.keyValue(inlineJTree.error);
    this.pricing = xml.keyValue(inlineJTree.pricing);
    this.extensions = inlineJTree.extensions;
  
    /** * Local Functions ***/
    function parseSurveys(inlineSurveys) {
      if (inlineSurveys) {
        return utilities.transformArray(utilities.isArray(inlineSurveys) ? inlineSurveys : [inlineSurveys], function (survey) {
          if (utilities.isNotEmptyString(survey.keyValue)) {
            return {
              uri: survey.keyValue,
              type: survey.attr('type')
            };
          }
  
          return undefined;
        });
      }
  
      return [];
    }
  }
  
  /**
   * Returns true if the browser supports all the creatives.
   */
  InLine.prototype.isSupported = function () {
    var i = void 0,
        len = void 0;
  
    if (this.creatives.length === 0) {
      return false;
    }
  
    for (i = 0, len = this.creatives.length; i < len; i += 1) {
      if (!this.creatives[i].isSupported()) {
        return false;
      }
    }
  
    return true;
  };
  
  module.exports = InLine;
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var parsers = __webpack_require__(23);
  var TrackingEvent = __webpack_require__(19);
  var VideoClicks = __webpack_require__(21);
  var MediaFile = __webpack_require__(37);
  
  function Linear(linearJTree) {
    if (!(this instanceof Linear)) {
      return new Linear(linearJTree);
    }
  
    // Required Elements
    this.duration = parsers.duration(xml.keyValue(linearJTree.duration));
    this.mediaFiles = parseMediaFiles(linearJTree.mediaFiles && linearJTree.mediaFiles.mediaFile);
  
    // Optional fields
    this.trackingEvents = parseTrackingEvents(linearJTree.trackingEvents && linearJTree.trackingEvents.tracking, this.duration);
    this.skipoffset = parsers.offset(xml.attr(linearJTree, 'skipoffset'), this.duration);
  
    if (linearJTree.videoClicks) {
      this.videoClicks = new VideoClicks(linearJTree.videoClicks);
    }
  
    if (linearJTree.adParameters) {
      this.adParameters = xml.keyValue(linearJTree.adParameters);
  
      if (xml.attr(linearJTree.adParameters, 'xmlEncoded')) {
        this.adParameters = xml.decode(this.adParameters);
      }
    }
  
    /** * Local functions ***/
    function parseTrackingEvents(trackingEvents, duration) {
      var trackings = [];
  
      if (utilities.isDefined(trackingEvents)) {
        trackingEvents = utilities.isArray(trackingEvents) ? trackingEvents : [trackingEvents];
        trackingEvents.forEach(function (trackingData) {
          trackings.push(new TrackingEvent(trackingData, duration));
        });
      }
  
      return trackings;
    }
  
    function parseMediaFiles(mediaFilesJxonTree) {
      var mediaFiles = [];
  
      if (utilities.isDefined(mediaFilesJxonTree)) {
        mediaFilesJxonTree = utilities.isArray(mediaFilesJxonTree) ? mediaFilesJxonTree : [mediaFilesJxonTree];
  
        mediaFilesJxonTree.forEach(function (mfData) {
          mediaFiles.push(new MediaFile(mfData));
        });
      }
  
      return mediaFiles;
    }
  }
  
  /**
   * Must return true if at least one of the MediaFiles' type is supported
   */
  Linear.prototype.isSupported = function () {
    var i = void 0,
        len = void 0;
  
    for (i = 0, len = this.mediaFiles.length; i < len; i += 1) {
      if (this.mediaFiles[i].isSupported()) {
        return true;
      }
    }
  
    return false;
  };
  
  module.exports = Linear;
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var xml = __webpack_require__(2);
  var parsers = __webpack_require__(23);
  
  function TrackingEvent(trackingJTree, duration) {
    if (!(this instanceof TrackingEvent)) {
      return new TrackingEvent(trackingJTree, duration);
    }
  
    this.name = trackingJTree.attr('event');
    this.uri = xml.keyValue(trackingJTree);
  
    if ('progress' === this.name) {
      this.offset = parsers.offset(trackingJTree.attr('offset'), duration);
    }
  }
  
  module.exports = TrackingEvent;
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var VASTError = __webpack_require__(3);
  var VASTResponse = __webpack_require__(8);
  var vastUtil = __webpack_require__(4);
  
  function VASTTracker(assetURI, vastResponse) {
    if (!(this instanceof VASTTracker)) {
      return new VASTTracker(assetURI, vastResponse);
    }
  
    this.sanityCheck(assetURI, vastResponse);
    this.initialize(assetURI, vastResponse);
  }
  
  VASTTracker.prototype.initialize = function (assetURI, vastResponse) {
    this.response = vastResponse;
    this.assetURI = assetURI;
    this.progress = 0;
    this.quartiles = {
      firstQuartile: { tracked: false, time: Math.round(25 * vastResponse.duration) / 100 },
      midpoint: { tracked: false, time: Math.round(50 * vastResponse.duration) / 100 },
      thirdQuartile: { tracked: false, time: Math.round(75 * vastResponse.duration) / 100 }
    };
  };
  
  VASTTracker.prototype.sanityCheck = function (assetURI, vastResponse) {
    if (!utilities.isString(assetURI) || utilities.isEmptyString(assetURI)) {
      throw new VASTError('on VASTTracker constructor, missing required the URI of the ad asset being played');
    }
  
    if (!(vastResponse instanceof VASTResponse)) {
      throw new VASTError('on VASTTracker constructor, missing required VAST response');
    }
  };
  
  VASTTracker.prototype.trackURLs = function trackURLs(urls, variables) {
    if (utilities.isArray(urls) && urls.length > 0) {
      variables = utilities.extend({
        ASSETURI: this.assetURI,
        CONTENTPLAYHEAD: vastUtil.formatProgress(this.progress)
      }, variables || {});
  
      vastUtil.track(urls, variables);
    }
  };
  
  VASTTracker.prototype.trackEvent = function trackEvent(eventName, trackOnce) {
    this.trackURLs(getEventUris(this.response.trackingEvents[eventName]));
    if (trackOnce) {
      this.response.trackingEvents[eventName] = undefined;
    }
  
    /** * Local function ***/
    function getEventUris(trackingEvents) {
      var uris = void 0;
  
      if (trackingEvents) {
        uris = [];
        trackingEvents.forEach(function (event) {
          if (!event.uri) {
            return;
          }
  
          uris.push(event.uri);
        });
      }
  
      return uris;
    }
  };
  
  VASTTracker.prototype.trackProgress = function trackProgress(newProgressInMs) {
    var that = this;
    var events = [];
    var ONCE = true;
    var ALWAYS = false;
    var trackingEvents = this.response.trackingEvents;
  
    if (utilities.isNumber(newProgressInMs)) {
      addTrackEvent('start', ONCE, newProgressInMs > 0);
      addTrackEvent('rewind', ALWAYS, hasRewound(this.progress, newProgressInMs));
      addQuartileEvents(newProgressInMs);
      trackProgressEvents(newProgressInMs);
      trackEvents();
      this.progress = newProgressInMs;
    }
  
    /** * Local function ***/
    function hasRewound(currentProgress, newProgress) {
      var REWIND_THRESHOLD = 3000; // IOS video clock is very unreliable and we need a 3 seconds threshold to ensure that there was a rewind an that it was on purpose.
  
      return currentProgress > newProgressInMs && Math.abs(newProgress - currentProgress) > REWIND_THRESHOLD;
    }
  
    function addTrackEvent(eventName, trackOnce, canBeAdded) {
      if (trackingEvents[eventName] && canBeAdded) {
        events.push({
          name: eventName,
          trackOnce: Boolean(trackOnce)
        });
      }
    }
  
    function addQuartileEvents(progress) {
      var quartiles = that.quartiles;
      var firstQuartile = that.quartiles.firstQuartile;
      var midpoint = that.quartiles.midpoint;
      var thirdQuartile = that.quartiles.thirdQuartile;
  
      if (!firstQuartile.tracked) {
        trackQuartile('firstQuartile', progress);
      } else if (!midpoint.tracked) {
        trackQuartile('midpoint', progress);
      } else if (!thirdQuartile.tracked) {
        trackQuartile('thirdQuartile', progress);
      }
  
      /** * Local function ***/
      function trackQuartile(quartileName, progress) {
        var quartile = quartiles[quartileName];
  
        if (canBeTracked(quartile, progress)) {
          quartile.tracked = true;
          addTrackEvent(quartileName, ONCE, true);
        }
      }
    }
  
    function canBeTracked(quartile, progress) {
      var quartileTime = quartile.time;
  
      // We only fire the quartile event if the progress is bigger than the quartile time by 5 seconds at most.
      return progress >= quartileTime && progress <= quartileTime + 5000;
    }
  
    function trackProgressEvents(progress) {
      if (!utilities.isArray(trackingEvents.progress)) {
        return; // Nothing to track
      }
  
      var pendingProgressEvts = [];
  
      trackingEvents.progress.forEach(function (evt) {
        if (evt.offset <= progress) {
          that.trackURLs([evt.uri]);
        } else {
          pendingProgressEvts.push(evt);
        }
      });
      trackingEvents.progress = pendingProgressEvts;
    }
  
    function trackEvents() {
      events.forEach(function (event) {
        that.trackEvent(event.name, event.trackOnce);
      });
    }
  };
  
  ['rewind', 'fullscreen', 'exitFullscreen', 'pause', 'resume', 'mute', 'unmute', 'acceptInvitation', 'acceptInvitationLinear', 'collapse', 'expand'].forEach(function (eventName) {
    VASTTracker.prototype['track' + utilities.capitalize(eventName)] = function () {
      this.trackEvent(eventName);
    };
  });
  
  ['start', 'skip', 'close', 'closeLinear'].forEach(function (eventName) {
    VASTTracker.prototype['track' + utilities.capitalize(eventName)] = function () {
      this.trackEvent(eventName, true);
    };
  });
  
  ['firstQuartile', 'midpoint', 'thirdQuartile'].forEach(function (quartile) {
    VASTTracker.prototype['track' + utilities.capitalize(quartile)] = function () {
      this.quartiles[quartile].tracked = true;
      this.trackEvent(quartile, true);
    };
  });
  
  VASTTracker.prototype.trackComplete = function () {
    if (this.quartiles.thirdQuartile.tracked) {
      this.trackEvent('complete', true);
    }
  };
  
  VASTTracker.prototype.trackErrorWithCode = function trackErrorWithCode(errorcode) {
    if (utilities.isNumber(errorcode)) {
      this.trackURLs(this.response.errorURLMacros, { ERRORCODE: errorcode });
    }
  };
  
  VASTTracker.prototype.trackImpressions = function trackImpressions() {
    this.trackURLs(this.response.impressions);
  };
  
  VASTTracker.prototype.trackCreativeView = function trackCreativeView() {
    this.trackEvent('creativeView');
  };
  
  VASTTracker.prototype.trackClick = function trackClick() {
    this.trackURLs(this.response.clickTrackings);
  };
  
  module.exports = VASTTracker;
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  
  function VideoClicks(videoClickJTree) {
    if (!(this instanceof VideoClicks)) {
      return new VideoClicks(videoClickJTree);
    }
  
    this.clickThrough = xml.keyValue(videoClickJTree.clickThrough);
    this.clickTrackings = parseClickTrackings(videoClickJTree.clickTracking);
    this.customClicks = parseClickTrackings(videoClickJTree.customClick);
  
    /** * Local functions ***/
    function parseClickTrackings(trackingData) {
      var clickTrackings = [];
  
      if (trackingData) {
        trackingData = utilities.isArray(trackingData) ? trackingData : [trackingData];
        trackingData.forEach(function (clickTrackingData) {
          clickTrackings.push(xml.keyValue(clickTrackingData));
        });
      }
  
      return clickTrackings;
    }
  }
  
  module.exports = VideoClicks;
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var vastUtil = __webpack_require__(4);
  var Creative = __webpack_require__(16);
  
  function Wrapper(wrapperJTree) {
    if (!(this instanceof Wrapper)) {
      return new Wrapper(wrapperJTree);
    }
  
    // Required elements
    this.adSystem = xml.keyValue(wrapperJTree.adSystem);
    this.impressions = vastUtil.parseImpressions(wrapperJTree.impression);
    this.VASTAdTagURI = xml.keyValue(wrapperJTree.vASTAdTagURI);
  
    // Optional elements
    this.creatives = Creative.parseCreatives(wrapperJTree.creatives);
    this.error = xml.keyValue(wrapperJTree.error);
    this.extensions = wrapperJTree.extensions;
  
    // Optional attrs
    this.followAdditionalWrappers = utilities.isDefined(xml.attr(wrapperJTree, 'followAdditionalWrappers')) ? xml.attr(wrapperJTree, 'followAdditionalWrappers') : true;
    this.allowMultipleAds = xml.attr(wrapperJTree, 'allowMultipleAds');
    this.fallbackOnNoAd = xml.attr(wrapperJTree, 'fallbackOnNoAd');
  }
  
  module.exports = Wrapper;
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  
  var durationRegex = /(\d\d):(\d\d):(\d\d)(\.(\d\d\d))?/;
  
  var parsers = {
  
    duration: function parseDuration(durationStr) {
      var match = void 0,
          durationInMs = void 0;
  
      if (utilities.isString(durationStr)) {
        match = durationStr.match(durationRegex);
        if (match) {
          durationInMs = parseHoursToMs(match[1]) + parseMinToMs(match[2]) + parseSecToMs(match[3]) + parseInt(match[5] || 0, 10);
        }
      }
  
      return isNaN(durationInMs) ? null : durationInMs;
  
      /** * local functions ***/
      function parseHoursToMs(hourStr) {
        return parseInt(hourStr, 10) * 60 * 60 * 1000;
      }
  
      function parseMinToMs(minStr) {
        return parseInt(minStr, 10) * 60 * 1000;
      }
  
      function parseSecToMs(secStr) {
        return parseInt(secStr, 10) * 1000;
      }
    },
  
    offset: function parseOffset(offset, duration) {
      if (isPercentage(offset)) {
        return calculatePercentage(offset, duration);
      }
  
      return parsers.duration(offset);
  
      /** * Local function ***/
      function isPercentage(offset) {
        var percentageRegex = /^\d+(\.\d+)?%$/g;
  
        return percentageRegex.test(offset);
      }
  
      function calculatePercentage(percentStr, duration) {
        if (duration) {
          return calcPercent(duration, parseFloat(percentStr.replace('%', '')));
        }
  
        return null;
      }
  
      function calcPercent(quantity, percent) {
        return quantity * percent / 100;
      }
    }
  
  };
  
  module.exports = parsers;
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  
  /**
   *
   * IMPORTANT NOTE: This function comes from angularJs and was originally called urlResolve
   *                 you can take a look at the original code here https://github.com/angular/angular.js/blob/master/src/ng/urlUtils.js
   *
   * Implementation Notes for non-IE browsers
   * ----------------------------------------
   * Assigning a URL to the href property of an anchor DOM node, even one attached to the DOM,
   * results both in the normalizing and parsing of the URL.  Normalizing means that a relative
   * URL will be resolved into an absolute URL in the context of the application document.
   * Parsing means that the anchor node's host, hostname, protocol, port, pathname and related
   * properties are all populated to reflect the normalized URL.  This approach has wide
   * compatibility - Safari 1+, Mozilla 1+, Opera 7+,e etc.  See
   * http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
   *
   * Implementation Notes for IE
   * ---------------------------
   * IE >= 8 and <= 10 normalizes the URL when assigned to the anchor node similar to the other
   * browsers.  However, the parsed components will not be set if the URL assigned did not specify
   * them.  (e.g. if you assign a.href = "foo", then a.protocol, a.host, etc. will be empty.)  We
   * work around that by performing the parsing in a 2nd step by taking a previously normalized
   * URL (e.g. by assigning to a.href) and assigning it a.href again.  This correctly populates the
   * properties such as protocol, hostname, port, etc.
   *
   * IE7 does not normalize the URL when assigned to an anchor node.  (Apparently, it does, if one
   * uses the inner HTML approach to assign the URL as part of an HTML snippet -
   * http://stackoverflow.com/a/472729)  However, setting img[src] does normalize the URL.
   * Unfortunately, setting img[src] to something like "javascript:foo" on IE throws an exception.
   * Since the primary usage for normalizing URLs is to sanitize such URLs, we can't use that
   * method and IE < 8 is unsupported.
   *
   * References:
   *   http://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement
   *   http://www.aptana.com/reference/html/api/HTMLAnchorElement.html
   *   http://url.spec.whatwg.org/#urlutils
   *   https://github.com/angular/angular.js/pull/2902
   *   http://james.padolsey.com/javascript/parsing-urls-with-the-dom/
   *
   * @kind function
   * @param {string} url The URL to be parsed.
   * @description Normalizes and parses a URL.
   * @returns {object} Returns the normalized URL as a dictionary.
   *
   *   | member name   | Description    |
   *   |---------------|----------------|
   *   | href          | A normalized version of the provided URL if it was not an absolute URL |
   *   | protocol      | The protocol including the trailing colon                              |
   *   | host          | The host and port (if the port is non-default) of the normalizedUrl    |
   *   | search        | The search params, minus the question mark                             |
   *   | hash          | The hash string, minus the hash symbol
   *   | hostname      | The hostname
   *   | port          | The port, without ":"
   *   | pathname      | The pathname, beginning with "/"
   *
   */
  
  var urlParsingNode = document.createElement('a');
  
  /**
   * documentMode is an IE-only property
   * http://msdn.microsoft.com/en-us/library/ie/cc196988(v=vs.85).aspx
   */
  var msie = document.documentMode;
  
  function urlParts(url) {
    var href = url;
  
    if (msie) {
      // Normalize before parse.  Refer Implementation Notes on why this is
      // done in two steps on IE.
      urlParsingNode.setAttribute('href', href);
      href = urlParsingNode.href;
    }
  
    urlParsingNode.setAttribute('href', href);
  
    // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
    return {
      href: urlParsingNode.href,
      protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
      host: urlParsingNode.host,
      search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
      hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
      hostname: urlParsingNode.hostname,
      port: utilities.isNotEmptyString(urlParsingNode.port) ? urlParsingNode.port : 80,
      pathname: urlParsingNode.pathname.charAt(0) === '/' ? urlParsingNode.pathname : '/' + urlParsingNode.pathname
    };
  }
  
  /**
   * This function accepts a query string (search part of a url) and returns a dictionary with
   * the different key value pairs
   * @param {string} qs queryString
   */
  function queryStringToObj(qs, cond) {
    var pairs = void 0,
        qsObj = void 0;
  
    cond = utilities.isFunction(cond) ? cond : function () {
      return true;
    };
  
    qs = qs.trim().replace(/^\?/, '');
    pairs = qs.split('&');
    qsObj = {};
  
    utilities.forEach(pairs, function (pair) {
      var keyValue = void 0,
          key = void 0,
          value = void 0;
  
      if (pair !== '') {
        keyValue = pair.split('=');
        key = keyValue[0];
        value = keyValue[1];
        if (cond(key, value)) {
          qsObj[key] = value;
        }
      }
    });
  
    return qsObj;
  }
  
  /**
   * This function accepts an object and serializes it into a query string without the leading '?'
   * @param obj
   * @returns {string}
   */
  function objToQueryString(obj) {
    var pairs = [];
  
    utilities.forEach(obj, function (value, key) {
      pairs.push(key + '=' + value);
    });
  
    return pairs.join('&');
  }
  
  module.exports = {
    urlParts: urlParts,
    queryStringToObj: queryStringToObj,
    objToQueryString: objToQueryString
  };
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports) {
  
  /*	SWFObject v2.2 <http://code.google.com/p/swfobject/> 
  	is released under the MIT License <http://www.opensource.org/licenses/mit-license.php> 
  */
  var swfobject=function(){var D="undefined",r="object",S="Shockwave Flash",W="ShockwaveFlash.ShockwaveFlash",q="application/x-shockwave-flash",R="SWFObjectExprInst",x="onreadystatechange",O=window,j=document,t=navigator,T=false,U=[h],o=[],N=[],I=[],l,Q,E,B,J=false,a=false,n,G,m=true,M=function(){var aa=typeof j.getElementById!=D&&typeof j.getElementsByTagName!=D&&typeof j.createElement!=D,ah=t.userAgent.toLowerCase(),Y=t.platform.toLowerCase(),ae=Y?/win/.test(Y):/win/.test(ah),ac=Y?/mac/.test(Y):/mac/.test(ah),af=/webkit/.test(ah)?parseFloat(ah.replace(/^.*webkit\/(\d+(\.\d+)?).*$/,"$1")):false,X=!+"\v1",ag=[0,0,0],ab=null;if(typeof t.plugins!=D&&typeof t.plugins[S]==r){ab=t.plugins[S].description;if(ab&&!(typeof t.mimeTypes!=D&&t.mimeTypes[q]&&!t.mimeTypes[q].enabledPlugin)){T=true;X=false;ab=ab.replace(/^.*\s+(\S+\s+\S+$)/,"$1");ag[0]=parseInt(ab.replace(/^(.*)\..*$/,"$1"),10);ag[1]=parseInt(ab.replace(/^.*\.(.*)\s.*$/,"$1"),10);ag[2]=/[a-zA-Z]/.test(ab)?parseInt(ab.replace(/^.*[a-zA-Z]+(.*)$/,"$1"),10):0}}else{if(typeof O[(['Active'].concat('Object').join('X'))]!=D){try{var ad=new window[(['Active'].concat('Object').join('X'))](W);if(ad){ab=ad.GetVariable("$version");if(ab){X=true;ab=ab.split(" ")[1].split(",");ag=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}}catch(Z){}}}return{w3:aa,pv:ag,wk:af,ie:X,win:ae,mac:ac}}(),k=function(){if(!M.w3){return}if((typeof j.readyState!=D&&j.readyState=="complete")||(typeof j.readyState==D&&(j.getElementsByTagName("body")[0]||j.body))){f()}if(!J){if(typeof j.addEventListener!=D){j.addEventListener("DOMContentLoaded",f,false)}if(M.ie&&M.win){j.attachEvent(x,function(){if(j.readyState=="complete"){j.detachEvent(x,arguments.callee);f()}});if(O==top){(function(){if(J){return}try{j.documentElement.doScroll("left")}catch(X){setTimeout(arguments.callee,0);return}f()})()}}if(M.wk){(function(){if(J){return}if(!/loaded|complete/.test(j.readyState)){setTimeout(arguments.callee,0);return}f()})()}s(f)}}();function f(){if(J){return}try{var Z=j.getElementsByTagName("body")[0].appendChild(C("span"));Z.parentNode.removeChild(Z)}catch(aa){return}J=true;var X=U.length;for(var Y=0;Y<X;Y++){U[Y]()}}function K(X){if(J){X()}else{U[U.length]=X}}function s(Y){if(typeof O.addEventListener!=D){O.addEventListener("load",Y,false)}else{if(typeof j.addEventListener!=D){j.addEventListener("load",Y,false)}else{if(typeof O.attachEvent!=D){i(O,"onload",Y)}else{if(typeof O.onload=="function"){var X=O.onload;O.onload=function(){X();Y()}}else{O.onload=Y}}}}}function h(){if(T){V()}else{H()}}function V(){var X=j.getElementsByTagName("body")[0];var aa=C(r);aa.setAttribute("type",q);var Z=X.appendChild(aa);if(Z){var Y=0;(function(){if(typeof Z.GetVariable!=D){var ab=Z.GetVariable("$version");if(ab){ab=ab.split(" ")[1].split(",");M.pv=[parseInt(ab[0],10),parseInt(ab[1],10),parseInt(ab[2],10)]}}else{if(Y<10){Y++;setTimeout(arguments.callee,10);return}}X.removeChild(aa);Z=null;H()})()}else{H()}}function H(){var ag=o.length;if(ag>0){for(var af=0;af<ag;af++){var Y=o[af].id;var ab=o[af].callbackFn;var aa={success:false,id:Y};if(M.pv[0]>0){var ae=c(Y);if(ae){if(F(o[af].swfVersion)&&!(M.wk&&M.wk<312)){w(Y,true);if(ab){aa.success=true;aa.ref=z(Y);ab(aa)}}else{if(o[af].expressInstall&&A()){var ai={};ai.data=o[af].expressInstall;ai.width=ae.getAttribute("width")||"0";ai.height=ae.getAttribute("height")||"0";if(ae.getAttribute("class")){ai.styleclass=ae.getAttribute("class")}if(ae.getAttribute("align")){ai.align=ae.getAttribute("align")}var ah={};var X=ae.getElementsByTagName("param");var ac=X.length;for(var ad=0;ad<ac;ad++){if(X[ad].getAttribute("name").toLowerCase()!="movie"){ah[X[ad].getAttribute("name")]=X[ad].getAttribute("value")}}P(ai,ah,Y,ab)}else{p(ae);if(ab){ab(aa)}}}}}else{w(Y,true);if(ab){var Z=z(Y);if(Z&&typeof Z.SetVariable!=D){aa.success=true;aa.ref=Z}ab(aa)}}}}}function z(aa){var X=null;var Y=c(aa);if(Y&&Y.nodeName=="OBJECT"){if(typeof Y.SetVariable!=D){X=Y}else{var Z=Y.getElementsByTagName(r)[0];if(Z){X=Z}}}return X}function A(){return !a&&F("6.0.65")&&(M.win||M.mac)&&!(M.wk&&M.wk<312)}function P(aa,ab,X,Z){a=true;E=Z||null;B={success:false,id:X};var ae=c(X);if(ae){if(ae.nodeName=="OBJECT"){l=g(ae);Q=null}else{l=ae;Q=X}aa.id=R;if(typeof aa.width==D||(!/%$/.test(aa.width)&&parseInt(aa.width,10)<310)){aa.width="310"}if(typeof aa.height==D||(!/%$/.test(aa.height)&&parseInt(aa.height,10)<137)){aa.height="137"}j.title=j.title.slice(0,47)+" - Flash Player Installation";var ad=M.ie&&M.win?(['Active'].concat('').join('X')):"PlugIn",ac="MMredirectURL="+O.location.toString().replace(/&/g,"%26")+"&MMplayerType="+ad+"&MMdoctitle="+j.title;if(typeof ab.flashvars!=D){ab.flashvars+="&"+ac}else{ab.flashvars=ac}if(M.ie&&M.win&&ae.readyState!=4){var Y=C("div");X+="SWFObjectNew";Y.setAttribute("id",X);ae.parentNode.insertBefore(Y,ae);ae.style.display="none";(function(){if(ae.readyState==4){ae.parentNode.removeChild(ae)}else{setTimeout(arguments.callee,10)}})()}u(aa,ab,X)}}function p(Y){if(M.ie&&M.win&&Y.readyState!=4){var X=C("div");Y.parentNode.insertBefore(X,Y);X.parentNode.replaceChild(g(Y),X);Y.style.display="none";(function(){if(Y.readyState==4){Y.parentNode.removeChild(Y)}else{setTimeout(arguments.callee,10)}})()}else{Y.parentNode.replaceChild(g(Y),Y)}}function g(ab){var aa=C("div");if(M.win&&M.ie){aa.innerHTML=ab.innerHTML}else{var Y=ab.getElementsByTagName(r)[0];if(Y){var ad=Y.childNodes;if(ad){var X=ad.length;for(var Z=0;Z<X;Z++){if(!(ad[Z].nodeType==1&&ad[Z].nodeName=="PARAM")&&!(ad[Z].nodeType==8)){aa.appendChild(ad[Z].cloneNode(true))}}}}}return aa}function u(ai,ag,Y){var X,aa=c(Y);if(M.wk&&M.wk<312){return X}if(aa){if(typeof ai.id==D){ai.id=Y}if(M.ie&&M.win){var ah="";for(var ae in ai){if(ai[ae]!=Object.prototype[ae]){if(ae.toLowerCase()=="data"){ag.movie=ai[ae]}else{if(ae.toLowerCase()=="styleclass"){ah+=' class="'+ai[ae]+'"'}else{if(ae.toLowerCase()!="classid"){ah+=" "+ae+'="'+ai[ae]+'"'}}}}}var af="";for(var ad in ag){if(ag[ad]!=Object.prototype[ad]){af+='<param name="'+ad+'" value="'+ag[ad]+'" />'}}aa.outerHTML='<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000"'+ah+">"+af+"</object>";N[N.length]=ai.id;X=c(ai.id)}else{var Z=C(r);Z.setAttribute("type",q);for(var ac in ai){if(ai[ac]!=Object.prototype[ac]){if(ac.toLowerCase()=="styleclass"){Z.setAttribute("class",ai[ac])}else{if(ac.toLowerCase()!="classid"){Z.setAttribute(ac,ai[ac])}}}}for(var ab in ag){if(ag[ab]!=Object.prototype[ab]&&ab.toLowerCase()!="movie"){e(Z,ab,ag[ab])}}aa.parentNode.replaceChild(Z,aa);X=Z}}return X}function e(Z,X,Y){var aa=C("param");aa.setAttribute("name",X);aa.setAttribute("value",Y);Z.appendChild(aa)}function y(Y){var X=c(Y);if(X&&X.nodeName=="OBJECT"){if(M.ie&&M.win){X.style.display="none";(function(){if(X.readyState==4){b(Y)}else{setTimeout(arguments.callee,10)}})()}else{X.parentNode.removeChild(X)}}}function b(Z){var Y=c(Z);if(Y){for(var X in Y){if(typeof Y[X]=="function"){Y[X]=null}}Y.parentNode.removeChild(Y)}}function c(Z){var X=null;try{X=j.getElementById(Z)}catch(Y){}return X}function C(X){return j.createElement(X)}function i(Z,X,Y){Z.attachEvent(X,Y);I[I.length]=[Z,X,Y]}function F(Z){var Y=M.pv,X=Z.split(".");X[0]=parseInt(X[0],10);X[1]=parseInt(X[1],10)||0;X[2]=parseInt(X[2],10)||0;return(Y[0]>X[0]||(Y[0]==X[0]&&Y[1]>X[1])||(Y[0]==X[0]&&Y[1]==X[1]&&Y[2]>=X[2]))?true:false}function v(ac,Y,ad,ab){if(M.ie&&M.mac){return}var aa=j.getElementsByTagName("head")[0];if(!aa){return}var X=(ad&&typeof ad=="string")?ad:"screen";if(ab){n=null;G=null}if(!n||G!=X){var Z=C("style");Z.setAttribute("type","text/css");Z.setAttribute("media",X);n=aa.appendChild(Z);if(M.ie&&M.win&&typeof j.styleSheets!=D&&j.styleSheets.length>0){n=j.styleSheets[j.styleSheets.length-1]}G=X}if(M.ie&&M.win){if(n&&typeof n.addRule==r){n.addRule(ac,Y)}}else{if(n&&typeof j.createTextNode!=D){n.appendChild(j.createTextNode(ac+" {"+Y+"}"))}}}function w(Z,X){if(!m){return}var Y=X?"visible":"hidden";if(J&&c(Z)){c(Z).style.visibility=Y}else{v("#"+Z,"visibility:"+Y)}}function L(Y){var Z=/[\\\"<>\.;]/;var X=Z.exec(Y)!=null;return X&&typeof encodeURIComponent!=D?encodeURIComponent(Y):Y}var d=function(){if(M.ie&&M.win){window.attachEvent("onunload",function(){var ac=I.length;for(var ab=0;ab<ac;ab++){I[ab][0].detachEvent(I[ab][1],I[ab][2])}var Z=N.length;for(var aa=0;aa<Z;aa++){y(N[aa])}for(var Y in M){M[Y]=null}M=null;for(var X in swfobject){swfobject[X]=null}swfobject=null})}}();return{registerObject:function(ab,X,aa,Z){if(M.w3&&ab&&X){var Y={};Y.id=ab;Y.swfVersion=X;Y.expressInstall=aa;Y.callbackFn=Z;o[o.length]=Y;w(ab,false)}else{if(Z){Z({success:false,id:ab})}}},getObjectById:function(X){if(M.w3){return z(X)}},embedSWF:function(ab,ah,ae,ag,Y,aa,Z,ad,af,ac){var X={success:false,id:ah};if(M.w3&&!(M.wk&&M.wk<312)&&ab&&ah&&ae&&ag&&Y){w(ah,false);K(function(){ae+="";ag+="";var aj={};if(af&&typeof af===r){for(var al in af){aj[al]=af[al]}}aj.data=ab;aj.width=ae;aj.height=ag;var am={};if(ad&&typeof ad===r){for(var ak in ad){am[ak]=ad[ak]}}if(Z&&typeof Z===r){for(var ai in Z){if(typeof am.flashvars!=D){am.flashvars+="&"+ai+"="+Z[ai]}else{am.flashvars=ai+"="+Z[ai]}}}if(F(Y)){var an=u(aj,am,ah);if(aj.id==ah){w(ah,true)}X.success=true;X.ref=an}else{if(aa&&A()){aj.data=aa;P(aj,am,ah,ac);return}else{w(ah,true)}}if(ac){ac(X)}})}else{if(ac){ac(X)}}},switchOffAutoHideShow:function(){m=false},ua:M,getFlashPlayerVersion:function(){return{major:M.pv[0],minor:M.pv[1],release:M.pv[2]}},hasFlashPlayerVersion:F,createSWF:function(Z,Y,X){if(M.w3){return u(Z,Y,X)}else{return undefined}},showExpressInstall:function(Z,aa,X,Y){if(M.w3&&A()){P(Z,aa,X,Y)}},removeSWF:function(X){if(M.w3){y(X)}},createCSS:function(aa,Z,Y,X){if(M.w3){v(aa,Z,Y,X)}},addDomLoadEvent:K,addLoadEvent:s,getQueryParamValue:function(aa){var Z=j.location.search||j.location.hash;if(Z){if(/\?/.test(Z)){Z=Z.split("?")[1]}if(aa==null){return L(Z)}var Y=Z.split("&");for(var X=0;X<Y.length;X++){if(Y[X].substring(0,Y[X].indexOf("="))==aa){return L(Y[X].substring((Y[X].indexOf("=")+1)))}}}return""},expressInstallCallback:function(){if(a){var X=c(R);if(X&&l){X.parentNode.replaceChild(l,X);if(Q){w(Q,true);if(M.ie&&M.win){l.style.display="block"}}if(E){E(B)}}a=false}}}}();module.exports=swfobject;
  
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var VASTClient = __webpack_require__(38);
  var VASTError = __webpack_require__(3);
  var vastUtil = __webpack_require__(4);
  var VASTIntegrator = __webpack_require__(39);
  var VPAIDIntegrator = __webpack_require__(43);
  var async = __webpack_require__(9);
  var dom = __webpack_require__(6);
  var playerUtils = __webpack_require__(11);
  var utilities = __webpack_require__(0);
  var logger = __webpack_require__(5);
  
  module.exports = function VASTPlugin(options) {
    var snapshot = void 0;
    var player = this;
    var vast = new VASTClient();
    var adsCanceled = false;
    var defaultOpts = {
      // maximum amount of time in ms to wait to receive `adsready` from the ad
      // implementation after play has been requested. Ad implementations are
      // expected to load any dynamic libraries and make any requests to determine
      // ad policies for a video during this time.
      timeout: 500,
  
      // Whenever you play an add on IOS, the native player kicks in and we loose control of it. On very heavy pages the 'play' event
      // May occur after the video content has already started. This is wrong if you want to play a preroll ad that needs to happen before the user
      // starts watching the content. To prevent this usec
      iosPrerollCancelTimeout: 2000,
  
      // maximun amount of time for the ad to actually start playing. If this timeout gets
      // triggered the ads will be cancelled
      adCancelTimeout: 3000,
  
      // Boolean flag that configures the player to play a new ad before the user sees the video again
      // the current video
      playAdAlways: false,
  
      // Flag to enable or disable the ads by default.
      adsEnabled: true,
  
      // Boolean flag to enable or disable the resize with window.resize or orientationchange
      autoResize: true,
  
      // Path to the VPAID flash ad's loader
      vpaidFlashLoaderPath: '/VPAIDFlash.swf',
  
      // verbosity of console logging:
      // 0 - error
      // 1 - error, warn
      // 2 - error, warn, info
      // 3 - error, warn, info, log
      // 4 - error, warn, info, log, debug
      verbosity: 0
    };
  
    var settings = utilities.extend({}, defaultOpts, options || {});
  
    if (utilities.isUndefined(settings.getAdTag) && utilities.isDefined(settings.adTag)) {
      settings.getAdTag = function (callback) {
        return callback(null, settings.adTag);
      };
    }
  
    if (utilities.isDefined(settings.adTagXML) && !utilities.isFunction(settings.adTagXML)) {
      return trackAdError(new VASTError('on VideoJS VAST plugin, the passed adTagXML option does not contain a function'));
    }
  
    if (!utilities.isFunction(settings.adTagXML) && !utilities.isFunction(settings.getAdTag)) {
      return trackAdError(new VASTError('on VideoJS VAST plugin, missing adTag on options object'));
    }
  
    logger.setVerbosity(settings.verbosity);
  
    vastUtil.runFlashSupportCheck(settings.vpaidFlashLoaderPath); // Necessary step for VPAIDFLASHClient to work.
  
    playerUtils.prepareForAds(player);
  
    if (settings.playAdAlways) {
      // No matter what happens we play a new ad before the user sees the video again.
      player.on('vast.contentEnd', function () {
        setTimeout(function () {
          player.trigger('vast.reset');
        }, 0);
      });
    }
  
    player.on('vast.firstPlay', tryToPlayPrerollAd);
  
    player.on('vast.reset', function () {
      // If we are reseting the plugin, we don't want to restore the content
      snapshot = null;
      cancelAds();
    });
  
    player.vast = {
      isEnabled: function isEnabled() {
        return settings.adsEnabled;
      },
  
      enable: function enable() {
        settings.adsEnabled = true;
      },
  
      disable: function disable() {
        settings.adsEnabled = false;
      }
    };
  
    return player.vast;
  
    /** ** Local functions ****/
    function tryToPlayPrerollAd() {
      // We remove the poster to prevent flickering whenever the content starts playing
      playerUtils.removeNativePoster(player);
  
      playerUtils.once(player, ['vast.adsCancel', 'vast.adEnd'], function () {
        removeAdUnit();
        restoreVideoContent();
      });
  
      async.waterfall([checkAdsEnabled, preparePlayerForAd, startAdCancelTimeout, playPrerollAd], function (error, response) {
        if (error) {
          trackAdError(error, response);
        } else {
          player.trigger('vast.adEnd');
        }
      });
  
      /** * Local functions ***/
  
      function removeAdUnit() {
        if (player.vast && player.vast.adUnit) {
          player.vast.adUnit = null; // We remove the adUnit
        }
      }
  
      function restoreVideoContent() {
        setupContentEvents();
        if (snapshot) {
          playerUtils.restorePlayerSnapshot(player, snapshot);
          snapshot = null;
        }
      }
  
      function setupContentEvents() {
        playerUtils.once(player, ['playing', 'vast.reset', 'vast.firstPlay'], function (evt) {
          if (evt.type !== 'playing') {
            return;
          }
  
          player.trigger('vast.contentStart');
  
          playerUtils.once(player, ['ended', 'vast.reset', 'vast.firstPlay'], function (evt) {
            if (evt.type === 'ended') {
              player.trigger('vast.contentEnd');
            }
          });
        });
      }
  
      function checkAdsEnabled(next) {
        if (settings.adsEnabled) {
          return next(null);
        }
        next(new VASTError('Ads are not enabled'));
      }
  
      function preparePlayerForAd(next) {
        if (canPlayPrerollAd()) {
          snapshot = playerUtils.getPlayerSnapshot(player);
          player.pause();
          addSpinnerIcon();
  
          if (player.paused()) {
            next(null);
          } else {
            playerUtils.once(player, ['playing'], function () {
              player.pause();
              next(null);
            });
          }
        } else {
          next(new VASTError('video content has been playing before preroll ad'));
        }
      }
  
      function canPlayPrerollAd() {
        return !utilities.isIPhone() || player.currentTime() <= settings.iosPrerollCancelTimeout;
      }
  
      function startAdCancelTimeout(next) {
        var adCancelTimeoutId = void 0;
  
        adsCanceled = false;
  
        adCancelTimeoutId = setTimeout(function () {
          trackAdError(new VASTError('timeout while waiting for the video to start playing', 402));
        }, settings.adCancelTimeout);
  
        playerUtils.once(player, ['vast.adStart', 'vast.adsCancel'], clearAdCancelTimeout);
  
        /** * local functions ***/
        function clearAdCancelTimeout() {
          if (adCancelTimeoutId) {
            clearTimeout(adCancelTimeoutId);
            adCancelTimeoutId = null;
          }
        }
  
        next(null);
      }
  
      function addSpinnerIcon() {
        dom.addClass(player.el(), 'vjs-vast-ad-loading');
        playerUtils.once(player, ['vast.adStart', 'vast.adsCancel'], removeSpinnerIcon);
      }
  
      function removeSpinnerIcon() {
        // IMPORTANT NOTE: We remove the spinnerIcon asynchronously to give time to the browser to start the video.
        // If we remove it synchronously we see a flash of the content video before the ad starts playing.
        setTimeout(function () {
          dom.removeClass(player.el(), 'vjs-vast-ad-loading');
        }, 100);
      }
    }
  
    function cancelAds() {
      player.trigger('vast.adsCancel');
      adsCanceled = true;
    }
  
    function playPrerollAd(callback) {
      async.waterfall([getVastResponse, playAd], callback);
    }
  
    function getVastResponse(callback) {
      if (settings.getAdTag) {
        return settings.getAdTag(function (error, adTag) {
          if (error) {
            return trackAdError(error);
          }
  
          return vast.getVASTResponse(adTag, callback);
        });
      }
  
      vast.getVASTResponse(settings.adTagXML, callback);
    }
  
    function playAd(vastResponse, callback) {
      // If the state is not 'preroll?' it means the ads were canceled therefore, we break the waterfall
      if (adsCanceled) {
        return;
      }
  
      var adIntegrator = isVPAID(vastResponse) ? new VPAIDIntegrator(player, settings) : new VASTIntegrator(player);
      var adFinished = false;
  
      playerUtils.once(player, ['vast.adStart', 'vast.adsCancel'], function (evt) {
        if (evt.type === 'vast.adStart') {
          addAdsLabel();
        }
      });
  
      playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel'], removeAdsLabel);
  
      if (utilities.isIDevice()) {
        preventManualProgress();
      }
  
      player.vast.vastResponse = vastResponse;
      logger.debug('calling adIntegrator.playAd() with vastResponse:', vastResponse);
      player.vast.adUnit = adIntegrator.playAd(vastResponse, callback);
  
      /** * Local functions ****/
      function addAdsLabel() {
        if (adFinished || player.controlBar.getChild('AdsLabel')) {
          return;
        }
  
        player.controlBar.addChild('AdsLabel');
      }
  
      function removeAdsLabel() {
        player.controlBar.removeChild('AdsLabel');
        adFinished = true;
      }
  
      function preventManualProgress() {
        // IOS video clock is very unreliable and we need a 3 seconds threshold to ensure that the user forwarded/rewound the ad
        var PROGRESS_THRESHOLD = 3;
        var previousTime = 0;
        var skipad_attempts = 0;
  
        player.on('timeupdate', preventAdSeek);
        player.on('ended', preventAdSkip);
  
        playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel', 'vast.adError'], stopPreventManualProgress);
  
        /** * Local functions ***/
        function preventAdSkip() {
          // Ignore ended event if the Ad time was not 'near' the end
          // and revert time to the previous 'valid' time
          if (player.duration() - previousTime > PROGRESS_THRESHOLD) {
            player.pause(true); // this reduce the video jitter if the IOS skip button is pressed
            player.play(true); // we need to trigger the play to put the video element back in a valid state
            player.currentTime(previousTime);
          }
        }
  
        function preventAdSeek() {
          var currentTime = player.currentTime();
          var progressDelta = Math.abs(currentTime - previousTime);
  
          if (progressDelta > PROGRESS_THRESHOLD) {
            skipad_attempts += 1;
            if (skipad_attempts >= 2) {
              player.pause(true);
            }
            player.currentTime(previousTime);
          } else {
            previousTime = currentTime;
          }
        }
  
        function stopPreventManualProgress() {
          player.off('timeupdate', preventAdSeek);
          player.off('ended', preventAdSkip);
        }
      }
    }
  
    function trackAdError(error, vastResponse) {
      player.trigger({ type: 'vast.adError', error: error });
      cancelAds();
      logger.error('AD ERROR:', error.message, error, vastResponse);
    }
  
    function isVPAID(vastResponse) {
      var i = void 0,
          len = void 0;
      var mediaFiles = vastResponse.mediaFiles;
  
      for (i = 0, len = mediaFiles.length; i < len; i++) {
        if (vastUtil.isVPAID(mediaFiles[i])) {
          return true;
        }
      }
  
      return false;
    }
  };
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(47);
  if(typeof content === 'string') content = [[module.i, content, '']];
  // add the styles to the DOM
  var update = __webpack_require__(50)(content, {});
  if(content.locals) module.exports = content.locals;
  // Hot Module Replacement
  if(false) {
  	// When the styles change, update the <style> tags
  	if(!content.locals) {
  		module.hot.accept("!!../../node_modules/css-loader/index.js??ref--2-1!../../node_modules/autoprefixer-loader/index.js??ref--2-2!../../node_modules/resolve-url-loader/index.js!../../node_modules/sass-loader/index.js!./videojs.vast.vpaid.scss", function() {
  			var newContent = require("!!../../node_modules/css-loader/index.js??ref--2-1!../../node_modules/autoprefixer-loader/index.js??ref--2-2!../../node_modules/resolve-url-loader/index.js!../../node_modules/sass-loader/index.js!./videojs.vast.vpaid.scss");
  			if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
  			update(newContent);
  		});
  	}
  	// When the module is disposed, remove the <style> tags
  	module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  //simple representation of the API
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var IVPAIDAdUnit = exports.IVPAIDAdUnit = function () {
      function IVPAIDAdUnit() {
          _classCallCheck(this, IVPAIDAdUnit);
      }
  
      _createClass(IVPAIDAdUnit, [{
          key: 'handshakeVersion',
  
  
          //all methods below
          //are async methods
          value: function handshakeVersion() {
              var playerVPAIDVersion = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '2.0';
              var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
          }
  
          //creativeData is an object to be consistent with VPAIDHTML
  
      }, {
          key: 'initAd',
          value: function initAd(width, height, viewMode, desiredBitrate) {
              var creativeData = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : { AdParameters: '' };
              var environmentVars = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : { flashVars: '' };
              var callback = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;
          }
      }, {
          key: 'resizeAd',
          value: function resizeAd(width, height, viewMode) {
              var callback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
          }
      }, {
          key: 'startAd',
          value: function startAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'stopAd',
          value: function stopAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'pauseAd',
          value: function pauseAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'resumeAd',
          value: function resumeAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'expandAd',
          value: function expandAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'collapseAd',
          value: function collapseAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
      }, {
          key: 'skipAd',
          value: function skipAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
          }
  
          //properties that will be treat as async methods
  
      }, {
          key: 'getAdLinear',
          value: function getAdLinear(callback) {}
      }, {
          key: 'getAdWidth',
          value: function getAdWidth(callback) {}
      }, {
          key: 'getAdHeight',
          value: function getAdHeight(callback) {}
      }, {
          key: 'getAdExpanded',
          value: function getAdExpanded(callback) {}
      }, {
          key: 'getAdSkippableState',
          value: function getAdSkippableState(callback) {}
      }, {
          key: 'getAdRemainingTime',
          value: function getAdRemainingTime(callback) {}
      }, {
          key: 'getAdDuration',
          value: function getAdDuration(callback) {}
      }, {
          key: 'setAdVolume',
          value: function setAdVolume(soundVolume) {
              var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
          }
      }, {
          key: 'getAdVolume',
          value: function getAdVolume(callback) {}
      }, {
          key: 'getAdCompanions',
          value: function getAdCompanions(callback) {}
      }, {
          key: 'getAdIcons',
          value: function getAdIcons(callback) {}
      }]);
  
      return IVPAIDAdUnit;
  }();
  
  Object.defineProperty(IVPAIDAdUnit, 'EVENTS', {
      writable: false,
      configurable: false,
      value: ['AdLoaded', 'AdStarted', 'AdStopped', 'AdSkipped', 'AdSkippableStateChange', // VPAID 2.0 new event
      'AdSizeChange', // VPAID 2.0 new event
      'AdLinearChange', 'AdDurationChange', // VPAID 2.0 new event
      'AdExpandedChange', 'AdRemainingTimeChange', // [Deprecated in 2.0] but will be still fired for backwards compatibility
      'AdVolumeChange', 'AdImpression', 'AdVideoStart', 'AdVideoFirstQuartile', 'AdVideoMidpoint', 'AdVideoThirdQuartile', 'AdVideoComplete', 'AdClickThru', 'AdInteraction', // VPAID 2.0 new event
      'AdUserAcceptInvitation', 'AdUserMinimize', 'AdUserClose', 'AdPaused', 'AdPlaying', 'AdLog', 'AdError']
  });
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  var IVPAIDAdUnit = __webpack_require__(28).IVPAIDAdUnit;
  var ALL_VPAID_METHODS = Object.getOwnPropertyNames(IVPAIDAdUnit.prototype).filter(function (property) {
      return ['constructor'].indexOf(property) === -1;
  });
  
  var VPAIDAdUnit = exports.VPAIDAdUnit = function (_IVPAIDAdUnit) {
      _inherits(VPAIDAdUnit, _IVPAIDAdUnit);
  
      function VPAIDAdUnit(flash) {
          _classCallCheck(this, VPAIDAdUnit);
  
          var _this = _possibleConstructorReturn(this, (VPAIDAdUnit.__proto__ || Object.getPrototypeOf(VPAIDAdUnit)).call(this));
  
          _this._destroyed = false;
          _this._flash = flash;
          return _this;
      }
  
      _createClass(VPAIDAdUnit, [{
          key: '_destroy',
          value: function _destroy() {
              var _this2 = this;
  
              this._destroyed = true;
              ALL_VPAID_METHODS.forEach(function (methodName) {
                  _this2._flash.removeCallbackByMethodName(methodName);
              });
              IVPAIDAdUnit.EVENTS.forEach(function (event) {
                  _this2._flash.offEvent(event);
              });
  
              this._flash = null;
          }
      }, {
          key: 'isDestroyed',
          value: function isDestroyed() {
              return this._destroyed;
          }
      }, {
          key: 'on',
          value: function on(eventName, callback) {
              this._flash.on(eventName, callback);
          }
      }, {
          key: 'off',
          value: function off(eventName, callback) {
              this._flash.off(eventName, callback);
          }
  
          //VPAID interface
  
      }, {
          key: 'handshakeVersion',
          value: function handshakeVersion() {
              var playerVPAIDVersion = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '2.0';
              var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
              this._flash.callFlashMethod('handshakeVersion', [playerVPAIDVersion], callback);
          }
      }, {
          key: 'initAd',
          value: function initAd(width, height, viewMode, desiredBitrate) {
              var creativeData = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : { AdParameters: '' };
              var environmentVars = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : { flashVars: '' };
              var callback = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : undefined;
  
              //resize element that has the flash object
              this._flash.setSize(width, height);
              creativeData = creativeData || { AdParameters: '' };
              environmentVars = environmentVars || { flashVars: '' };
  
              this._flash.callFlashMethod('initAd', [this._flash.getWidth(), this._flash.getHeight(), viewMode, desiredBitrate, creativeData.AdParameters || '', environmentVars.flashVars || ''], callback);
          }
      }, {
          key: 'resizeAd',
          value: function resizeAd(width, height, viewMode) {
              var callback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
  
              //resize element that has the flash object
              this._flash.setSize(width, height);
  
              //resize ad inside the flash
              this._flash.callFlashMethod('resizeAd', [this._flash.getWidth(), this._flash.getHeight(), viewMode], callback);
          }
      }, {
          key: 'startAd',
          value: function startAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('startAd', [], callback);
          }
      }, {
          key: 'stopAd',
          value: function stopAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('stopAd', [], callback);
          }
      }, {
          key: 'pauseAd',
          value: function pauseAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('pauseAd', [], callback);
          }
      }, {
          key: 'resumeAd',
          value: function resumeAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('resumeAd', [], callback);
          }
      }, {
          key: 'expandAd',
          value: function expandAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('expandAd', [], callback);
          }
      }, {
          key: 'collapseAd',
          value: function collapseAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('collapseAd', [], callback);
          }
      }, {
          key: 'skipAd',
          value: function skipAd() {
              var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
  
              this._flash.callFlashMethod('skipAd', [], callback);
          }
  
          //properties that will be treat as async methods
  
      }, {
          key: 'getAdLinear',
          value: function getAdLinear(callback) {
              this._flash.callFlashMethod('getAdLinear', [], callback);
          }
      }, {
          key: 'getAdWidth',
          value: function getAdWidth(callback) {
              this._flash.callFlashMethod('getAdWidth', [], callback);
          }
      }, {
          key: 'getAdHeight',
          value: function getAdHeight(callback) {
              this._flash.callFlashMethod('getAdHeight', [], callback);
          }
      }, {
          key: 'getAdExpanded',
          value: function getAdExpanded(callback) {
              this._flash.callFlashMethod('getAdExpanded', [], callback);
          }
      }, {
          key: 'getAdSkippableState',
          value: function getAdSkippableState(callback) {
              this._flash.callFlashMethod('getAdSkippableState', [], callback);
          }
      }, {
          key: 'getAdRemainingTime',
          value: function getAdRemainingTime(callback) {
              this._flash.callFlashMethod('getAdRemainingTime', [], callback);
          }
      }, {
          key: 'getAdDuration',
          value: function getAdDuration(callback) {
              this._flash.callFlashMethod('getAdDuration', [], callback);
          }
      }, {
          key: 'setAdVolume',
          value: function setAdVolume(volume) {
              var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
  
              this._flash.callFlashMethod('setAdVolume', [volume], callback);
          }
      }, {
          key: 'getAdVolume',
          value: function getAdVolume(callback) {
              this._flash.callFlashMethod('getAdVolume', [], callback);
          }
      }, {
          key: 'getAdCompanions',
          value: function getAdCompanions(callback) {
              this._flash.callFlashMethod('getAdCompanions', [], callback);
          }
      }, {
          key: 'getAdIcons',
          value: function getAdIcons(callback) {
              this._flash.callFlashMethod('getAdIcons', [], callback);
          }
      }]);
  
      return VPAIDAdUnit;
  }(IVPAIDAdUnit);
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
      value: true
  });
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var swfobject = __webpack_require__(25);
  
  var FLASH_TEST = 'vpaid_video_flash_tester';
  var FLASH_TEST_EL = 'vpaid_video_flash_tester_el';
  var JSFlashBridge = __webpack_require__(13).JSFlashBridge;
  var utils = __webpack_require__(1);
  var MultipleValuesRegistry = __webpack_require__(7).MultipleValuesRegistry;
  
  var FlashTester = function () {
      function FlashTester(parent) {
          var _this = this;
  
          var swfConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { data: 'VPAIDFlash.swf', width: 800, height: 400 };
  
          _classCallCheck(this, FlashTester);
  
          this.parentEl = utils.createElementWithID(parent, FLASH_TEST_EL); // some browsers create global variables using the element id http://stackoverflow.com/questions/3434278/do-dom-tree-elements-with-ids-become-global-variables
          utils.hideFlashEl(this.parentEl);
          var params = {};
          params.movie = swfConfig.data;
          params.FlashVars = 'flashid=' + FLASH_TEST_EL + '&handler=' + JSFlashBridge.VPAID_FLASH_HANDLER;
          params.allowScriptAccess = 'always';
  
          this.el = swfobject.createSWF(swfConfig, params, FLASH_TEST_EL);
          this._handlers = new MultipleValuesRegistry();
          this._isSupported = false;
          if (this.el) {
              utils.hideFlashEl(this.el);
              this._flash = new JSFlashBridge(this.el, swfConfig.data, FLASH_TEST_EL, swfConfig.width, swfConfig.height, function () {
                  var support = true;
                  _this._isSupported = support;
                  _this._handlers.get('change').forEach(function (callback) {
                      setTimeout(function () {
                          callback('change', support);
                      }, 0);
                  });
              });
          }
      }
  
      _createClass(FlashTester, [{
          key: 'isSupported',
          value: function isSupported() {
              return this._isSupported;
          }
      }, {
          key: 'on',
          value: function on(eventName, callback) {
              this._handlers.add(eventName, callback);
          }
      }]);
  
      return FlashTester;
  }();
  
  var createFlashTester = exports.createFlashTester = function createFlashTester(el, swfConfig) {
      if (!window[FLASH_TEST]) {
          window[FLASH_TEST] = new FlashTester(el, swfConfig);
      }
      return window[FLASH_TEST];
  };
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var SingleValueRegistry = __webpack_require__(7).SingleValueRegistry;
  var instances = new SingleValueRegistry();
  
  var JSFlashBridgeRegistry = {};
  Object.defineProperty(JSFlashBridgeRegistry, 'addInstance', {
      writable: false,
      configurable: false,
      value: function value(id, instance) {
          instances.add(id, instance);
      }
  });
  
  Object.defineProperty(JSFlashBridgeRegistry, 'getInstanceByID', {
      writable: false,
      configurable: false,
      value: function value(id) {
          return instances.get(id);
      }
  });
  
  Object.defineProperty(JSFlashBridgeRegistry, 'removeInstanceByID', {
      writable: false,
      configurable: false,
      value: function value(id) {
          return instances.remove(id);
      }
  });
  
  module.exports = JSFlashBridgeRegistry;
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var METHODS = ['handshakeVersion', 'initAd', 'startAd', 'stopAd', 'skipAd', // VPAID 2.0 new method
  'resizeAd', 'pauseAd', 'resumeAd', 'expandAd', 'collapseAd', 'subscribe', 'unsubscribe'];
  
  var EVENTS = ['AdLoaded', 'AdStarted', 'AdStopped', 'AdSkipped', 'AdSkippableStateChange', // VPAID 2.0 new event
  'AdSizeChange', // VPAID 2.0 new event
  'AdLinearChange', 'AdDurationChange', // VPAID 2.0 new event
  'AdExpandedChange', 'AdRemainingTimeChange', // [Deprecated in 2.0] but will be still fired for backwards compatibility
  'AdVolumeChange', 'AdImpression', 'AdVideoStart', 'AdVideoFirstQuartile', 'AdVideoMidpoint', 'AdVideoThirdQuartile', 'AdVideoComplete', 'AdClickThru', 'AdInteraction', // VPAID 2.0 new event
  'AdUserAcceptInvitation', 'AdUserMinimize', 'AdUserClose', 'AdPaused', 'AdPlaying', 'AdLog', 'AdError'];
  
  var GETTERS = ['getAdLinear', 'getAdWidth', // VPAID 2.0 new getter
  'getAdHeight', // VPAID 2.0 new getter
  'getAdExpanded', 'getAdSkippableState', // VPAID 2.0 new getter
  'getAdRemainingTime', 'getAdDuration', // VPAID 2.0 new getter
  'getAdVolume', 'getAdCompanions', // VPAID 2.0 new getter
  'getAdIcons' // VPAID 2.0 new getter
  ];
  
  var SETTERS = ['setAdVolume'];
  
  /**
   * This callback is displayed as global member. The callback use nodejs error-first callback style
   * @callback NodeStyleCallback
   * @param {string|null}
   * @param {undefined|object}
   */
  
  /**
   * IVPAIDAdUnit
   *
   * @class
   *
   * @param {object} creative
   * @param {HTMLElement} el
   * @param {HTMLVideoElement} video
   */
  function IVPAIDAdUnit(creative, el, video) {}
  
  /**
   * handshakeVersion
   *
   * @param {string} VPAIDVersion
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.handshakeVersion = function (VPAIDVersion, callback) {};
  
  /**
   * initAd
   *
   * @param {number} width
   * @param {number} height
   * @param {string} viewMode can be 'normal', 'thumbnail' or 'fullscreen'
   * @param {number} desiredBitrate indicates the desired bitrate in kbps
   * @param {object} [creativeData] used for additional initialization data
   * @param {object} [environmentVars] used for passing implementation-specific of js version
   * @param {NodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.initAd = function (width, height, viewMode, desiredBitrate, creativeData, environmentVars, callback) {};
  
  /**
   * startAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.startAd = function (callback) {};
  
  /**
   * stopAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.stopAd = function (callback) {};
  
  /**
   * skipAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.skipAd = function (callback) {};
  
  /**
   * resizeAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.resizeAd = function (width, height, viewMode, callback) {};
  
  /**
   * pauseAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.pauseAd = function (callback) {};
  
  /**
   * resumeAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.resumeAd = function (callback) {};
  
  /**
   * expandAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.expandAd = function (callback) {};
  
  /**
   * collapseAd
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.collapseAd = function (callback) {};
  
  /**
   * subscribe
   *
   * @param {string} event
   * @param {nodeStyleCallback} handler
   * @param {object} context
   */
  IVPAIDAdUnit.prototype.subscribe = function (event, handler, context) {};
  
  /**
   * startAd
   *
   * @param {string} event
   * @param {function} handler
   */
  IVPAIDAdUnit.prototype.unsubscribe = function (event, handler) {};
  
  /**
   * getAdLinear
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdLinear = function (callback) {};
  
  /**
   * getAdWidth
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdWidth = function (callback) {};
  
  /**
   * getAdHeight
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdHeight = function (callback) {};
  
  /**
   * getAdExpanded
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdExpanded = function (callback) {};
  
  /**
   * getAdSkippableState
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdSkippableState = function (callback) {};
  
  /**
   * getAdRemainingTime
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdRemainingTime = function (callback) {};
  
  /**
   * getAdDuration
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdDuration = function (callback) {};
  
  /**
   * getAdVolume
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdVolume = function (callback) {};
  
  /**
   * getAdCompanions
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdCompanions = function (callback) {};
  
  /**
   * getAdIcons
   *
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.getAdIcons = function (callback) {};
  
  /**
   * setAdVolume
   *
   * @param {number} volume
   * @param {nodeStyleCallback} callback
   */
  IVPAIDAdUnit.prototype.setAdVolume = function (volume, callback) {};
  
  addStaticToInterface(IVPAIDAdUnit, 'METHODS', METHODS);
  addStaticToInterface(IVPAIDAdUnit, 'GETTERS', GETTERS);
  addStaticToInterface(IVPAIDAdUnit, 'SETTERS', SETTERS);
  addStaticToInterface(IVPAIDAdUnit, 'EVENTS', EVENTS);
  
  var VPAID1_METHODS = METHODS.filter(function (method) {
    return ['skipAd'].indexOf(method) === -1;
  });
  
  addStaticToInterface(IVPAIDAdUnit, 'checkVPAIDInterface', function checkVPAIDInterface(creative) {
    var result = VPAID1_METHODS.every(function (key) {
      return typeof creative[key] === 'function';
    });
    return result;
  });
  
  module.exports = IVPAIDAdUnit;
  
  function addStaticToInterface(Interface, name, value) {
    Object.defineProperty(Interface, name, {
      writable: false,
      configurable: false,
      value: value
    });
  }
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var IVPAIDAdUnit = __webpack_require__(32);
  var Subscriber = __webpack_require__(35);
  var checkVPAIDInterface = IVPAIDAdUnit.checkVPAIDInterface;
  var utils = __webpack_require__(14);
  var METHODS = IVPAIDAdUnit.METHODS;
  var ERROR = 'AdError';
  var AD_CLICK = 'AdClickThru';
  var FILTERED_EVENTS = IVPAIDAdUnit.EVENTS.filter(function (event) {
      return event != AD_CLICK;
  });
  
  /**
   * This callback is displayed as global member. The callback use nodejs error-first callback style
   * @callback NodeStyleCallback
   * @param {string|null}
   * @param {undefined|object}
   */
  
  /**
   * VPAIDAdUnit
   * @class
   *
   * @param VPAIDCreative
   * @param {HTMLElement} [el] this will be used in initAd environmentVars.slot if defined
   * @param {HTMLVideoElement} [video] this will be used in initAd environmentVars.videoSlot if defined
   */
  function VPAIDAdUnit(VPAIDCreative, el, video, iframe) {
      this._isValid = checkVPAIDInterface(VPAIDCreative);
      if (this._isValid) {
          this._creative = VPAIDCreative;
          this._el = el;
          this._videoEl = video;
          this._iframe = iframe;
          this._subscribers = new Subscriber();
          utils.setFullSizeStyle(el);
          $addEventsSubscribers.call(this);
      }
  }
  
  VPAIDAdUnit.prototype = Object.create(IVPAIDAdUnit.prototype);
  
  /**
   * isValidVPAIDAd will return if the VPAIDCreative passed in constructor is valid or not
   *
   * @return {boolean}
   */
  VPAIDAdUnit.prototype.isValidVPAIDAd = function isValidVPAIDAd() {
      return this._isValid;
  };
  
  IVPAIDAdUnit.METHODS.forEach(function (method) {
      //NOTE: this methods arguments order are implemented differently from the spec
      var ignores = ['subscribe', 'unsubscribe', 'initAd'];
  
      if (ignores.indexOf(method) !== -1) return;
  
      VPAIDAdUnit.prototype[method] = function () {
          var ariaty = IVPAIDAdUnit.prototype[method].length;
          // TODO avoid leaking arguments
          // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
          var args = Array.prototype.slice.call(arguments);
          var callback = ariaty === args.length ? args.pop() : undefined;
  
          setTimeout(function () {
              var result,
                  error = null;
              try {
                  result = this._creative[method].apply(this._creative, args);
              } catch (e) {
                  error = e;
              }
  
              callOrTriggerEvent(callback, this._subscribers, error, result);
          }.bind(this), 0);
      };
  });
  
  /**
   * initAd concreate implementation
   *
   * @param {number} width
   * @param {number} height
   * @param {string} viewMode can be 'normal', 'thumbnail' or 'fullscreen'
   * @param {number} desiredBitrate indicates the desired bitrate in kbps
   * @param {object} [creativeData] used for additional initialization data
   * @param {object} [environmentVars] used for passing implementation-specific of js version, if el & video was used in constructor slot & videoSlot will be added to the object
   * @param {NodeStyleCallback} callback
   */
  VPAIDAdUnit.prototype.initAd = function initAd(width, height, viewMode, desiredBitrate, creativeData, environmentVars, callback) {
      creativeData = creativeData || {};
      environmentVars = utils.extend({
          slot: this._el,
          videoSlot: this._videoEl
      }, environmentVars || {});
  
      setTimeout(function () {
          var error;
          try {
              this._creative.initAd(width, height, viewMode, desiredBitrate, creativeData, environmentVars);
          } catch (e) {
              error = e;
          }
  
          callOrTriggerEvent(callback, this._subscribers, error);
      }.bind(this), 0);
  };
  
  /**
   * subscribe
   *
   * @param {string} event
   * @param {nodeStyleCallback} handler
   * @param {object} context
   */
  VPAIDAdUnit.prototype.subscribe = function subscribe(event, handler, context) {
      this._subscribers.subscribe(handler, event, context);
  };
  
  /**
   * unsubscribe
   *
   * @param {string} event
   * @param {nodeStyleCallback} handler
   */
  VPAIDAdUnit.prototype.unsubscribe = function unsubscribe(event, handler) {
      this._subscribers.unsubscribe(handler, event);
  };
  
  //alias
  VPAIDAdUnit.prototype.on = VPAIDAdUnit.prototype.subscribe;
  VPAIDAdUnit.prototype.off = VPAIDAdUnit.prototype.unsubscribe;
  
  IVPAIDAdUnit.GETTERS.forEach(function (getter) {
      VPAIDAdUnit.prototype[getter] = function (callback) {
          setTimeout(function () {
  
              var result,
                  error = null;
              try {
                  result = this._creative[getter]();
              } catch (e) {
                  error = e;
              }
  
              callOrTriggerEvent(callback, this._subscribers, error, result);
          }.bind(this), 0);
      };
  });
  
  /**
   * setAdVolume
   *
   * @param volume
   * @param {nodeStyleCallback} callback
   */
  VPAIDAdUnit.prototype.setAdVolume = function setAdVolume(volume, callback) {
      setTimeout(function () {
  
          var result,
              error = null;
          try {
              this._creative.setAdVolume(volume);
              result = this._creative.getAdVolume();
          } catch (e) {
              error = e;
          }
  
          if (!error) {
              error = utils.validate(result === volume, 'failed to apply volume: ' + volume);
          }
          callOrTriggerEvent(callback, this._subscribers, error, result);
      }.bind(this), 0);
  };
  
  VPAIDAdUnit.prototype._destroy = function destroy() {
      this.stopAd();
      this._subscribers.unsubscribeAll();
  };
  
  function $addEventsSubscribers() {
      // some ads implement
      // so they only handle one subscriber
      // to handle this we create our one
      FILTERED_EVENTS.forEach(function (event) {
          this._creative.subscribe($trigger.bind(this, event), event);
      }.bind(this));
  
      // map the click event to be an object instead of depending of the order of the arguments
      // and to be consistent with the flash
      this._creative.subscribe($clickThruHook.bind(this), AD_CLICK);
  
      // because we are adding the element inside the iframe
      // the user is not able to click in the video
      if (this._videoEl) {
          var documentElement = this._iframe.contentDocument.documentElement;
          var videoEl = this._videoEl;
          documentElement.addEventListener('click', function (e) {
              if (e.target === documentElement) {
                  videoEl.click();
              }
          });
      }
  }
  
  function $clickThruHook(url, id, playerHandles) {
      this._subscribers.triggerSync(AD_CLICK, { url: url, id: id, playerHandles: playerHandles });
  }
  
  function $trigger(event) {
      // TODO avoid leaking arguments
      // https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
      this._subscribers.trigger(event, Array.prototype.slice(arguments, 1));
  }
  
  function callOrTriggerEvent(callback, subscribers, error, result) {
      if (callback) {
          callback(error, result);
      } else if (error) {
          subscribers.trigger(ERROR, error);
      }
  }
  
  module.exports = VPAIDAdUnit;
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utils = __webpack_require__(14);
  var unique = utils.unique('vpaidIframe');
  var VPAIDAdUnit = __webpack_require__(33);
  
  var defaultTemplate = '<!DOCTYPE html>' + '<html lang="en">' + '<head><meta charset="UTF-8"></head>' + '<body style="margin:0;padding:0"><div class="ad-element"></div>' + '<script type="text/javascript" src="{{iframeURL_JS}}"></script>' + '<script type="text/javascript">' + 'window.parent.postMessage(\'{"event": "ready", "id": "{{iframeID}}"}\', \'{{origin}}\');' + '</script>' + '</body>' + '</html>';
  
  var AD_STOPPED = 'AdStopped';
  
  /**
   * This callback is displayed as global member. The callback use nodejs error-first callback style
   * @callback NodeStyleCallback
   * @param {string|null}
   * @param {undefined|object}
   */
  
  /**
   * VPAIDHTML5Client
   * @class
   *
   * @param {HTMLElement} el that will contain the iframe to load adUnit and a el to add to adUnit slot
   * @param {HTMLVideoElement} video default video element to be used by adUnit
   * @param {object} [templateConfig] template: html template to be used instead of the default, extraOptions: to be used when rendering the template
   * @param {object} [vpaidOptions] timeout: when loading adUnit
   */
  function VPAIDHTML5Client(el, video, templateConfig, vpaidOptions) {
      templateConfig = templateConfig || {};
  
      this._id = unique();
      this._destroyed = false;
  
      this._frameContainer = utils.createElementInEl(el, 'div');
      this._videoEl = video;
      this._vpaidOptions = vpaidOptions || { timeout: 10000 };
  
      this._templateConfig = {
          template: templateConfig.template || defaultTemplate,
          extraOptions: templateConfig.extraOptions || {}
      };
  }
  
  /**
   * destroy
   *
   */
  VPAIDHTML5Client.prototype.destroy = function destroy() {
      if (this._destroyed) {
          return;
      }
      this._destroyed = true;
      $unloadPreviousAdUnit.call(this);
  };
  
  /**
   * isDestroyed
   *
   * @return {boolean}
   */
  VPAIDHTML5Client.prototype.isDestroyed = function isDestroyed() {
      return this._destroyed;
  };
  
  /**
   * loadAdUnit
   *
   * @param {string} adURL url of the js of the adUnit
   * @param {nodeStyleCallback} callback
   */
  VPAIDHTML5Client.prototype.loadAdUnit = function loadAdUnit(adURL, callback) {
      $throwIfDestroyed.call(this);
      $unloadPreviousAdUnit.call(this);
      var that = this;
  
      var frame = utils.createIframeWithContent(this._frameContainer, this._templateConfig.template, utils.extend({
          iframeURL_JS: adURL,
          iframeID: this.getID(),
          origin: getOrigin()
      }, this._templateConfig.extraOptions));
  
      this._frame = frame;
  
      this._onLoad = utils.callbackTimeout(this._vpaidOptions.timeout, onLoad.bind(this), onTimeout.bind(this));
  
      window.addEventListener('message', this._onLoad);
  
      function onLoad(e) {
          /*jshint validthis: false */
          //don't clear timeout
          if (e.origin !== getOrigin()) return;
          var result = JSON.parse(e.data);
  
          //don't clear timeout
          if (result.id !== that.getID()) return;
  
          var adUnit, error, createAd;
          if (!that._frame.contentWindow) {
  
              error = 'the iframe is not anymore in the DOM tree';
          } else {
              createAd = that._frame.contentWindow.getVPAIDAd;
              error = utils.validate(typeof createAd === 'function', 'the ad didn\'t return a function to create an ad');
          }
  
          if (!error) {
              var adEl = that._frame.contentWindow.document.querySelector('.ad-element');
              adUnit = new VPAIDAdUnit(createAd(), adEl, that._videoEl, that._frame);
              adUnit.subscribe(AD_STOPPED, $adDestroyed.bind(that));
              error = utils.validate(adUnit.isValidVPAIDAd(), 'the add is not fully complaint with VPAID specification');
          }
  
          that._adUnit = adUnit;
          $destroyLoadListener.call(that);
          callback(error, error ? null : adUnit);
  
          //clear timeout
          return true;
      }
  
      function onTimeout() {
          callback('timeout', null);
      }
  };
  
  /**
   * unloadAdUnit
   *
   */
  VPAIDHTML5Client.prototype.unloadAdUnit = function unloadAdUnit() {
      $unloadPreviousAdUnit.call(this);
  };
  
  /**
   * getID will return the unique id
   *
   * @return {string}
   */
  VPAIDHTML5Client.prototype.getID = function () {
      return this._id;
  };
  
  /**
   * $removeEl
   *
   * @param {string} key
   */
  function $removeEl(key) {
      var el = this[key];
      if (el) {
          el.remove();
          delete this[key];
      }
  }
  
  function $adDestroyed() {
      $removeAdElements.call(this);
      delete this._adUnit;
  }
  
  function $unloadPreviousAdUnit() {
      $removeAdElements.call(this);
      $destroyAdUnit.call(this);
  }
  
  function $removeAdElements() {
      $removeEl.call(this, '_frame');
      $destroyLoadListener.call(this);
  }
  
  /**
   * $destroyLoadListener
   *
   */
  function $destroyLoadListener() {
      if (this._onLoad) {
          window.removeEventListener('message', this._onLoad);
          utils.clearCallbackTimeout(this._onLoad);
          delete this._onLoad;
      }
  }
  
  function $destroyAdUnit() {
      if (this._adUnit) {
          this._adUnit.stopAd();
          delete this._adUnit;
      }
  }
  
  /**
   * $throwIfDestroyed
   *
   */
  function $throwIfDestroyed() {
      if (this._destroyed) {
          throw new Error('VPAIDHTML5Client already destroyed!');
      }
  }
  
  function getOrigin() {
      if (window.location.origin) {
          return window.location.origin;
      } else {
          return window.location.protocol + "//" + window.location.hostname + (window.location.port ? ':' + window.location.port : '');
      }
  }
  
  module.exports = VPAIDHTML5Client;
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  function Subscriber() {
      this._subscribers = {};
  }
  
  Subscriber.prototype.subscribe = function subscribe(handler, eventName, context) {
      if (!this.isHandlerAttached(handler, eventName)) {
          this.get(eventName).push({ handler: handler, context: context, eventName: eventName });
      }
  };
  
  Subscriber.prototype.unsubscribe = function unsubscribe(handler, eventName) {
      this._subscribers[eventName] = this.get(eventName).filter(function (subscriber) {
          return handler !== subscriber.handler;
      });
  };
  
  Subscriber.prototype.unsubscribeAll = function unsubscribeAll() {
      this._subscribers = {};
  };
  
  Subscriber.prototype.trigger = function (eventName, data) {
      var that = this;
      var subscribers = this.get(eventName).concat(this.get('*'));
  
      subscribers.forEach(function (subscriber) {
          setTimeout(function () {
              if (that.isHandlerAttached(subscriber.handler, subscriber.eventName)) {
                  subscriber.handler.call(subscriber.context, data);
              }
          }, 0);
      });
  };
  
  Subscriber.prototype.triggerSync = function (eventName, data) {
      var subscribers = this.get(eventName).concat(this.get('*'));
  
      subscribers.forEach(function (subscriber) {
          subscriber.handler.call(subscriber.context, data);
      });
  };
  
  Subscriber.prototype.get = function get(eventName) {
      if (!this._subscribers[eventName]) {
          this._subscribers[eventName] = [];
      }
      return this._subscribers[eventName];
  };
  
  Subscriber.prototype.isHandlerAttached = function isHandlerAttached(handler, eventName) {
      return this.get(eventName).some(function (subscriber) {
          return handler === subscriber.handler;
      });
  };
  
  module.exports = Subscriber;
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var logger = __webpack_require__(5);
  var TrackingEvent = __webpack_require__(19);
  
  function Companion(companionJTree) {
    if (!(this instanceof Companion)) {
      return new Companion(companionJTree);
    }
  
    logger.info('<Companion> found companion ad');
    logger.debug('<Companion>  companionJTree:', companionJTree);
  
    // Required Elements
    this.creativeType = xml.attr(companionJTree.staticResource, 'creativeType');
    this.staticResource = xml.keyValue(companionJTree.staticResource);
  
    logger.info('<Companion>  creativeType: ' + this.creativeType);
    logger.info('<Companion>  staticResource: ' + this.staticResource);
  
    // Weird bug when the JXON tree is built it doesn't handle casing properly in this situation...
    var htmlResource = null;
  
    if (xml.keyValue(companionJTree.HTMLResource)) {
      htmlResource = xml.keyValue(companionJTree.HTMLResource);
    } else if (xml.keyValue(companionJTree.hTMLResource)) {
      htmlResource = xml.keyValue(companionJTree.hTMLResource);
    }
  
    if (htmlResource !== null) {
      logger.info('<Companion> found html resource', htmlResource);
    }
  
    this.htmlResource = htmlResource;
  
    var iframeResource = null;
  
    if (xml.keyValue(companionJTree.IFrameResource)) {
      iframeResource = xml.keyValue(companionJTree.IFrameResource);
    } else if (xml.keyValue(companionJTree.iFrameresource)) {
      iframeResource = xml.keyValue(companionJTree.iFrameresource);
    }
  
    if (iframeResource !== null) {
      logger.info('<Companion> found iframe resource', iframeResource);
    }
  
    this.iframeResource = iframeResource;
  
    // Optional fields
    this.id = xml.attr(companionJTree, 'id');
    this.width = xml.attr(companionJTree, 'width');
    this.height = xml.attr(companionJTree, 'height');
    this.expandedWidth = xml.attr(companionJTree, 'expandedWidth');
    this.expandedHeight = xml.attr(companionJTree, 'expandedHeight');
    this.scalable = xml.attr(companionJTree, 'scalable');
    this.maintainAspectRatio = xml.attr(companionJTree, 'maintainAspectRatio');
    this.minSuggestedDuration = xml.attr(companionJTree, 'minSuggestedDuration');
    this.apiFramework = xml.attr(companionJTree, 'apiFramework');
    this.companionClickThrough = xml.keyValue(companionJTree.companionClickThrough);
    this.trackingEvents = parseTrackingEvents(companionJTree.trackingEvents && companionJTree.trackingEvents.tracking);
  
    logger.info('<Companion>  companionClickThrough: ' + this.companionClickThrough);
  
    /** * Local functions ***/
    function parseTrackingEvents(trackingEvents) {
      var trackings = [];
  
      if (utilities.isDefined(trackingEvents)) {
        trackingEvents = utilities.isArray(trackingEvents) ? trackingEvents : [trackingEvents];
        trackingEvents.forEach(function (trackingData) {
          trackings.push(new TrackingEvent(trackingData));
        });
      }
  
      return trackings;
    }
  }
  
  module.exports = Companion;
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var xml = __webpack_require__(2);
  var urlUtils = __webpack_require__(24);
  var vastUtil = __webpack_require__(4);
  
  var attributesList = [
  // Required attributes
  'delivery', 'type', 'width', 'height',
  
  // Optional attributes
  'codec', 'id', 'bitrate', 'minBitrate', 'maxBitrate', 'scalable', 'maintainAspectRatio', 'apiFramework'];
  
  var pageProtocol = window.location && urlUtils.urlParts(window.location.href).protocol;
  
  function MediaFile(mediaFileJTree) {
    if (!(this instanceof MediaFile)) {
      return new MediaFile(mediaFileJTree);
    }
  
    // Required attributes
    this.src = xml.keyValue(mediaFileJTree);
  
    for (var x = 0; x < attributesList.length; x++) {
      var attribute = attributesList[x];
  
      this[attribute] = mediaFileJTree.attr(attribute);
    }
  }
  
  MediaFile.prototype.isSupported = function () {
    if (vastUtil.isVPAID(this)) {
      return Boolean(vastUtil.findSupportedVPAIDTech(this.type));
    }
  
    if (this.type === 'video/x-flv') {
      return vastUtil.isFlashSupported();
    }
  
    if (pageProtocol === 'https') {
      return urlUtils.urlParts(this.src).protocol === pageProtocol;
    }
  
    return true;
  };
  
  module.exports = MediaFile;
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var async = __webpack_require__(9);
  var http = __webpack_require__(46).http;
  var utilities = __webpack_require__(0);
  var xml = __webpack_require__(2);
  var logger = __webpack_require__(5);
  var Ad = __webpack_require__(15);
  var VASTError = __webpack_require__(3);
  var VASTResponse = __webpack_require__(8);
  var vastUtil = __webpack_require__(4);
  
  function VASTClient(options) {
    if (!(this instanceof VASTClient)) {
      return new VASTClient(options);
    }
    var defaultOptions = {
      WRAPPER_LIMIT: 5
    };
  
    options = options || {};
    this.settings = utilities.extend({}, options, defaultOptions);
    this.errorURLMacros = [];
  }
  
  VASTClient.prototype.getVASTResponse = function getVASTResponse(adTag, callback) {
    var that = this;
  
    var error = sanityCheck(adTag, callback);
  
    if (error) {
      if (utilities.isFunction(callback)) {
        return callback(error);
      }
      throw error;
    }
  
    async.waterfall([this._getVASTAd.bind(this, adTag), buildVASTResponse], callback);
  
    /** * Local functions ***/
    function buildVASTResponse(adsChain, cb) {
      try {
        var response = that._buildVASTResponse(adsChain);
  
        cb(null, response);
      } catch (e) {
        cb(e);
      }
    }
  
    function sanityCheck(adTag, cb) {
      if (!adTag) {
        return new VASTError('on VASTClient.getVASTResponse, missing ad tag URL');
      }
  
      if (!utilities.isFunction(cb)) {
        return new VASTError('on VASTClient.getVASTResponse, missing callback function');
      }
    }
  };
  
  VASTClient.prototype._getVASTAd = function (adTag, callback) {
    var that = this;
  
    getAdWaterfall(adTag, function (error, vastTree) {
      var waterfallAds = vastTree && utilities.isArray(vastTree.ads) ? vastTree.ads : null;
  
      if (error) {
        that._trackError(error, waterfallAds);
  
        return callback(error, waterfallAds);
      }
  
      getAd(waterfallAds.shift(), [], waterfallHandler);
  
      /** * Local functions ***/
      function waterfallHandler(error, adChain) {
        if (error) {
          that._trackError(error, adChain);
          if (waterfallAds.length > 0) {
            getAd(waterfallAds.shift(), [], waterfallHandler);
          } else {
            callback(error, adChain);
          }
        } else {
          callback(null, adChain);
        }
      }
    });
  
    /** * Local functions ***/
    function getAdWaterfall(adTag, callback) {
      var requestVastXML = that._requestVASTXml.bind(that, adTag);
  
      async.waterfall([requestVastXML, buildVastWaterfall], callback);
    }
  
    function buildVastWaterfall(xmlStr, callback) {
      var vastTree = void 0;
  
      try {
        vastTree = xml.toJXONTree(xmlStr);
        logger.debug('built JXONTree from VAST response:', vastTree);
  
        if (utilities.isArray(vastTree.ad)) {
          vastTree.ads = vastTree.ad;
        } else if (vastTree.ad) {
          vastTree.ads = [vastTree.ad];
        } else {
          vastTree.ads = [];
        }
        callback(validateVASTTree(vastTree), vastTree);
      } catch (e) {
        callback(new VASTError('on VASTClient.getVASTAd.buildVastWaterfall, error parsing xml', 100), null);
      }
    }
  
    function validateVASTTree(vastTree) {
      var vastVersion = xml.attr(vastTree, 'version');
  
      if (!vastTree.ad) {
        return new VASTError('on VASTClient.getVASTAd.validateVASTTree, no Ad in VAST tree', 303);
      }
  
      if (vastVersion && vastVersion !== 3 && vastVersion !== 2) {
        return new VASTError('on VASTClient.getVASTAd.validateVASTTree, not supported VAST version "' + vastVersion + '"', 102);
      }
  
      return null;
    }
  
    function getAd(adTag, adChain, callback) {
      if (adChain.length >= that.WRAPPER_LIMIT) {
        return callback(new VASTError('on VASTClient.getVASTAd.getAd, players wrapper limit reached (the limit is ' + that.WRAPPER_LIMIT + ')', 302), adChain);
      }
  
      async.waterfall([function (next) {
        if (utilities.isString(adTag)) {
          requestVASTAd(adTag, next);
        } else {
          next(null, adTag);
        }
      }, buildAd], function (error, ad) {
        if (ad) {
          adChain.push(ad);
        }
  
        if (error) {
          return callback(error, adChain);
        }
  
        if (ad.wrapper) {
          return getAd(ad.wrapper.VASTAdTagURI, adChain, callback);
        }
  
        return callback(null, adChain);
      });
    }
  
    function buildAd(adJxonTree, callback) {
      try {
        var ad = new Ad(adJxonTree);
  
        callback(validateAd(ad), ad);
      } catch (e) {
        callback(new VASTError('on VASTClient.getVASTAd.buildAd, error parsing xml', 100), null);
      }
    }
  
    function validateAd(ad) {
      var wrapper = ad.wrapper;
      var inLine = ad.inLine;
      var errMsgPrefix = 'on VASTClient.getVASTAd.validateAd, ';
  
      if (inLine && wrapper) {
        return new VASTError(errMsgPrefix + 'InLine and Wrapper both found on the same Ad', 101);
      }
  
      if (!inLine && !wrapper) {
        return new VASTError(errMsgPrefix + 'nor wrapper nor inline elements found on the Ad', 101);
      }
  
      if (inLine && !inLine.isSupported()) {
        return new VASTError(errMsgPrefix + 'could not find MediaFile that is supported by this video player', 403);
      }
  
      if (wrapper && !wrapper.VASTAdTagURI) {
        return new VASTError(errMsgPrefix + 'missing \'VASTAdTagURI\' in wrapper', 101);
      }
  
      return null;
    }
  
    function requestVASTAd(adTag, callback) {
      that._requestVASTXml(adTag, function (error, xmlStr) {
        if (error) {
          return callback(error);
        }
        try {
          var vastTree = xml.toJXONTree(xmlStr);
  
          callback(validateVASTTree(vastTree), vastTree.ad);
        } catch (e) {
          callback(new VASTError('on VASTClient.getVASTAd.requestVASTAd, error parsing xml', 100));
        }
      });
    }
  };
  
  VASTClient.prototype._requestVASTXml = function requestVASTXml(adTag, callback) {
    try {
      if (utilities.isFunction(adTag)) {
        adTag(requestHandler);
      } else {
        logger.info('requesting adTag: ' + adTag);
        http.get(adTag, requestHandler, {
          withCredentials: true
        });
      }
    } catch (e) {
      callback(e);
    }
  
    /** * Local functions ***/
    function requestHandler(error, response, status) {
      if (error) {
        var errMsg = utilities.isDefined(status) ? 'on VASTClient.requestVastXML, HTTP request error with status \'' + status + '\'' : 'on VASTClient.requestVastXML, Error getting the the VAST XML with he passed adTagXML fn';
  
        return callback(new VASTError(errMsg, 301), null);
      }
  
      callback(null, response);
    }
  };
  
  VASTClient.prototype._buildVASTResponse = function buildVASTResponse(adsChain) {
    var response = new VASTResponse();
  
    addAdsToResponse(response, adsChain);
    validateResponse(response);
  
    return response;
  
    //* ** Local function ****
    function addAdsToResponse(response, ads) {
      ads.forEach(function (ad) {
        response.addAd(ad);
      });
    }
  
    function validateResponse(response) {
      var progressEvents = response.trackingEvents.progress;
  
      if (!response.hasLinear()) {
        throw new VASTError('on VASTClient._buildVASTResponse, Received an Ad type that is not supported', 200);
      }
  
      if (response.duration === undefined) {
        throw new VASTError('on VASTClient._buildVASTResponse, Missing duration field in VAST response', 101);
      }
  
      if (progressEvents) {
        progressEvents.forEach(function (progressEvent) {
          if (!utilities.isNumber(progressEvent.offset)) {
            throw new VASTError('on VASTClient._buildVASTResponse, missing or wrong offset attribute on progress tracking event', 101);
          }
        });
      }
    }
  };
  
  VASTClient.prototype._trackError = function (error, adChain) {
    if (!utilities.isArray(adChain) || adChain.length === 0) {
      // There is nothing to track
      return;
    }
  
    var errorURLMacros = [];
  
    adChain.forEach(addErrorUrlMacros);
    vastUtil.track(errorURLMacros, { ERRORCODE: error.code || 900 }); // 900 <== Undefined error
  
    /** * Local functions  ***/
    function addErrorUrlMacros(ad) {
      if (ad.wrapper && ad.wrapper.error) {
        errorURLMacros.push(ad.wrapper.error);
      }
  
      if (ad.inLine && ad.inLine.error) {
        errorURLMacros.push(ad.inLine.error);
      }
    }
  };
  
  module.exports = VASTClient;
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var async = __webpack_require__(9);
  var dom = __webpack_require__(6);
  var playerUtils = __webpack_require__(11);
  var utilities = __webpack_require__(0);
  var logger = __webpack_require__(5);
  var VASTResponse = __webpack_require__(8);
  var VASTError = __webpack_require__(3);
  var VASTTracker = __webpack_require__(20);
  var vastUtil = __webpack_require__(4);
  
  function VASTIntegrator(player) {
    if (!(this instanceof VASTIntegrator)) {
      return new VASTIntegrator(player);
    }
  
    this.player = player;
  }
  
  VASTIntegrator.prototype.playAd = function playAd(vastResponse, callback) {
    var that = this;
  
    callback = callback || utilities.noop;
  
    if (!(vastResponse instanceof VASTResponse)) {
      return callback(new VASTError('On VASTIntegrator, missing required VASTResponse'));
    }
  
    async.waterfall([function (next) {
      next(null, vastResponse);
    }, this._selectAdSource.bind(this), this._createVASTTracker.bind(this), this._addClickThrough.bind(this), this._addSkipButton.bind(this), this._setupEvents.bind(this), this._playSelectedAd.bind(this)], function (error, response) {
      if (error && response) {
        that._trackError(error, response);
      }
      callback(error, response);
    });
  
    this._adUnit = {
      _src: null,
      type: 'VAST',
      pauseAd: function pauseAd() {
        that.player.pause(true);
      },
  
      resumeAd: function resumeAd() {
        that.player.play(true);
      },
  
      isPaused: function isPaused() {
        return that.player.paused(true);
      },
  
      getSrc: function getSrc() {
        return this._src;
      }
    };
  
    return this._adUnit;
  };
  
  VASTIntegrator.prototype._selectAdSource = function selectAdSource(response, callback) {
    var source = void 0;
  
    var playerWidth = dom.getDimension(this.player.el()).width;
    var mediaFiles = response.mediaFiles.filter(function (mediaFile) {
      return mediaFile.isSupported();
    });
  
    mediaFiles.sort(function (a, b) {
      var deltaA = Math.abs(playerWidth - a.width);
      var deltaB = Math.abs(playerWidth - b.width);
  
      return deltaA - deltaB;
    });
  
    source = this.player.selectSource(mediaFiles).source;
  
    if (source) {
      logger.info('selected source: ', source);
      if (this._adUnit) {
        this._adUnit._src = source;
      }
  
      return callback(null, source, response);
    }
  
    // code 403 <== Couldn't find MediaFile that is supported by this video player
    callback(new VASTError('Could not find Ad mediafile supported by this player', 403), response);
  };
  
  VASTIntegrator.prototype._createVASTTracker = function createVASTTracker(adMediaFile, response, callback) {
    try {
      callback(null, adMediaFile, new VASTTracker(adMediaFile.src, response), response);
    } catch (e) {
      callback(e, response);
    }
  };
  
  VASTIntegrator.prototype._setupEvents = function setupEvents(adMediaFile, tracker, response, callback) {
    var previouslyMuted = void 0;
    var player = this.player;
  
    player.on('fullscreenchange', trackFullscreenChange);
    player.on('vast.adStart', trackImpressions);
    player.on('pause', trackPause);
    player.on('timeupdate', trackProgress);
    player.on('volumechange', trackVolumeChange);
  
    playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel'], unbindEvents);
    playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel', 'vast.adSkip'], function (evt) {
      if (evt.type === 'vast.adEnd') {
        tracker.trackComplete();
      }
    });
  
    return callback(null, adMediaFile, response);
  
    /** * Local Functions ***/
    function unbindEvents() {
      player.off('fullscreenchange', trackFullscreenChange);
      player.off('vast.adStart', trackImpressions);
      player.off('pause', trackPause);
      player.off('timeupdate', trackProgress);
      player.off('volumechange', trackVolumeChange);
    }
  
    function trackFullscreenChange() {
      if (player.isFullscreen()) {
        tracker.trackFullscreen();
      } else {
        tracker.trackExitFullscreen();
      }
    }
  
    function trackPause() {
      // NOTE: whenever a video ends the video Element triggers a 'pause' event before the 'ended' event.
      //      We should not track this pause event because it makes the VAST tracking confusing again we use a
      //      Threshold of 2 seconds to prevent false positives on IOS.
      if (Math.abs(player.duration() - player.currentTime()) < 2) {
        return;
      }
  
      tracker.trackPause();
      playerUtils.once(player, ['play', 'vast.adEnd', 'vast.adsCancel'], function (evt) {
        if (evt.type === 'play') {
          tracker.trackResume();
        }
      });
    }
  
    function trackProgress() {
      var currentTimeInMs = player.currentTime() * 1000;
  
      tracker.trackProgress(currentTimeInMs);
    }
  
    function trackImpressions() {
      tracker.trackImpressions();
      tracker.trackCreativeView();
    }
  
    function trackVolumeChange() {
      var muted = player.muted();
  
      if (muted) {
        tracker.trackMute();
      } else if (previouslyMuted) {
        tracker.trackUnmute();
      }
      previouslyMuted = muted;
    }
  };
  
  VASTIntegrator.prototype._addSkipButton = function addSkipButton(source, tracker, response, callback) {
    var skipOffsetInSec = void 0;
    var that = this;
  
    if (utilities.isNumber(response.skipoffset)) {
      skipOffsetInSec = response.skipoffset / 1000;
      addSkipButtonToPlayer(this.player, skipOffsetInSec);
    }
    callback(null, source, tracker, response);
  
    /** * Local function ***/
    function addSkipButtonToPlayer(player, skipOffset) {
      var skipButton = createSkipButton(player);
      var updateSkipButton = updateSkipButtonState.bind(that, skipButton, skipOffset, player);
  
      player.el().appendChild(skipButton);
      player.on('timeupdate', updateSkipButton);
  
      playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel'], removeSkipButton);
  
      function removeSkipButton() {
        player.off('timeupdate', updateSkipButton);
        dom.remove(skipButton);
      }
    }
  
    function createSkipButton(player) {
      var skipButton = window.document.createElement('div');
  
      dom.addClass(skipButton, 'vast-skip-button');
  
      skipButton.onclick = function (e) {
        if (dom.hasClass(skipButton, 'enabled')) {
          tracker.trackSkip();
          player.trigger('vast.adSkip');
        }
  
        // We prevent event propagation to avoid problems with the clickThrough and so on
        if (window.Event.prototype.stopPropagation === undefined) {
          return false;
        } else {
          e.stopPropagation();
        }
      };
  
      return skipButton;
    }
  
    function updateSkipButtonState(skipButton, skipOffset, player) {
      var timeLeft = Math.ceil(skipOffset - player.currentTime());
  
      if (timeLeft > 0) {
        skipButton.innerHTML = 'Skip in ' + utilities.toFixedDigits(timeLeft, 2) + '...';
        // eslint-disable-next-line
      } else if (!dom.hasClass(skipButton, 'enabled')) {
        dom.addClass(skipButton, 'enabled');
        skipButton.innerHTML = 'Skip ad';
      }
    }
  };
  
  VASTIntegrator.prototype._addClickThrough = function addClickThrough(mediaFile, tracker, response, callback) {
    var player = this.player;
    var blocker = createClickThroughBlocker(player, tracker, response);
    var updateBlocker = updateBlockerURL.bind(this, blocker, response, player);
  
    player.el().insertBefore(blocker, player.controlBar.el());
    player.on('timeupdate', updateBlocker);
    playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel'], removeBlocker);
  
    return callback(null, mediaFile, tracker, response);
  
    /** * Local Functions ***/
  
    function createClickThroughBlocker(player, tracker, response) {
      var blocker = window.document.createElement('a');
      var clickThroughMacro = response.clickThrough;
  
      dom.addClass(blocker, 'vast-blocker');
      blocker.href = generateClickThroughURL(clickThroughMacro, player);
  
      if (utilities.isString(clickThroughMacro)) {
        blocker.target = '_blank';
      }
  
      blocker.onclick = function (e) {
        if (player.paused()) {
          player.play();
  
          // We prevent event propagation to avoid problems with the player's normal pause mechanism
          if (window.Event.prototype.stopPropagation !== undefined) {
            e.stopPropagation();
          }
  
          return false;
        }
  
        player.pause();
        tracker.trackClick();
      };
  
      return blocker;
    }
  
    function updateBlockerURL(blocker, response, player) {
      blocker.href = generateClickThroughURL(response.clickThrough, player);
    }
  
    function generateClickThroughURL(clickThroughMacro, player) {
      var variables = {
        ASSETURI: mediaFile.src,
        CONTENTPLAYHEAD: vastUtil.formatProgress(player.currentTime() * 1000)
      };
  
      return clickThroughMacro ? vastUtil.parseURLMacro(clickThroughMacro, variables) : '#';
    }
  
    function removeBlocker() {
      player.off('timeupdate', updateBlocker);
      dom.remove(blocker);
    }
  };
  
  VASTIntegrator.prototype._playSelectedAd = function playSelectedAd(source, response, callback) {
    var player = this.player;
  
    player.preload('auto'); // without preload=auto the durationchange event is never fired
    player.src(source);
  
    logger.debug('<VASTIntegrator._playSelectedAd> waiting for durationchange to play the ad...');
  
    playerUtils.once(player, ['durationchange', 'error', 'vast.adsCancel'], function (evt) {
      if (evt.type === 'durationchange') {
        logger.debug('<VASTIntegrator._playSelectedAd> got durationchange; calling playAd()');
        playAd();
      } else if (evt.type === 'error') {
        callback(new VASTError('on VASTIntegrator, Player is unable to play the Ad', 400), response);
      }
  
      // NOTE: If the ads get canceled we do nothing/
    });
  
    /** ** local functions ******/
    function playAd() {
      playerUtils.once(player, ['playing', 'vast.adsCancel'], function (evt) {
        if (evt.type === 'vast.adsCancel') {
          return;
        }
  
        logger.debug('<VASTIntegrator._playSelectedAd/playAd> got playing event; triggering vast.adStart...');
  
        player.trigger('vast.adStart');
  
        player.on('ended', proceed);
        player.on('vast.adsCancel', proceed);
        player.on('vast.adSkip', proceed);
  
        function proceed(evt) {
          if (evt.type === 'ended' && player.duration() - player.currentTime() > 3) {
            // Ignore ended event if the Ad time was not 'near' the end
            // avoids issues where IOS controls could skip the Ad
            return;
          }
  
          player.off('ended', proceed);
          player.off('vast.adsCancel', proceed);
          player.off('vast.adSkip', proceed);
  
          // NOTE: if the ads get cancel we do nothing apart removing the listners
          if (evt.type === 'ended' || evt.type === 'vast.adSkip') {
            callback(null, response);
          }
        }
      });
  
      logger.debug('<VASTIntegrator._playSelectedAd/playAd> calling player.play()...');
  
      player.play();
    }
  };
  
  VASTIntegrator.prototype._trackError = function trackError(error, response) {
    vastUtil.track(response.errorURLMacros, { ERRORCODE: error.code || 900 });
  };
  
  module.exports = VASTIntegrator;
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var VASTError = __webpack_require__(3);
  var utilities = __webpack_require__(0);
  
  function VPAIDAdUnitWrapper(vpaidAdUnit, opts) {
    if (!(this instanceof VPAIDAdUnitWrapper)) {
      return new VPAIDAdUnitWrapper(vpaidAdUnit, opts);
    }
    sanityCheck(vpaidAdUnit, opts);
  
    this.options = utilities.extend({}, opts);
  
    this._adUnit = vpaidAdUnit;
  
    /** * Local Functions ***/
    function sanityCheck(adUnit, opts) {
      if (!adUnit || !VPAIDAdUnitWrapper.checkVPAIDInterface(adUnit)) {
        throw new VASTError('on VPAIDAdUnitWrapper, the passed VPAID adUnit does not fully implement the VPAID interface');
      }
  
      if (!utilities.isObject(opts)) {
        throw new VASTError('on VPAIDAdUnitWrapper, expected options hash  but got \'' + opts + '\'');
      }
  
      if (!('responseTimeout' in opts) || !utilities.isNumber(opts.responseTimeout)) {
        throw new VASTError('on VPAIDAdUnitWrapper, expected responseTimeout in options');
      }
    }
  }
  
  VPAIDAdUnitWrapper.checkVPAIDInterface = function checkVPAIDInterface(VPAIDAdUnit) {
    // NOTE: skipAd is not part of the method list because it only appears in VPAID 2.0 and we support VPAID 1.0
    var VPAIDInterfaceMethods = ['handshakeVersion', 'initAd', 'startAd', 'stopAd', 'resizeAd', 'pauseAd', 'expandAd', 'collapseAd'];
  
    for (var i = 0, len = VPAIDInterfaceMethods.length; i < len; i++) {
      if (!VPAIDAdUnit || !utilities.isFunction(VPAIDAdUnit[VPAIDInterfaceMethods[i]])) {
        return false;
      }
    }
  
    return canSubscribeToEvents(VPAIDAdUnit) && canUnsubscribeFromEvents(VPAIDAdUnit);
  
    /** * Local Functions ***/
  
    function canSubscribeToEvents(adUnit) {
      return utilities.isFunction(adUnit.subscribe) || utilities.isFunction(adUnit.addEventListener) || utilities.isFunction(adUnit.on);
    }
  
    function canUnsubscribeFromEvents(adUnit) {
      return utilities.isFunction(adUnit.unsubscribe) || utilities.isFunction(adUnit.removeEventListener) || utilities.isFunction(adUnit.off);
    }
  };
  
  VPAIDAdUnitWrapper.prototype.adUnitAsyncCall = function () {
    var _adUnit;
  
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }
  
    var method = args.shift();
    var cb = args.pop();
    var timeoutId = void 0;
  
    sanityCheck(method, cb, this._adUnit);
    args.push(wrapCallback());
  
    (_adUnit = this._adUnit)[method].apply(_adUnit, args);
    timeoutId = setTimeout(function () {
      timeoutId = null;
      cb(new VASTError('on VPAIDAdUnitWrapper, timeout while waiting for a response on call \'' + method + '\''));
      cb = utilities.noop;
    }, this.options.responseTimeout);
  
    /** * Local functions ***/
    function sanityCheck(method, cb, adUnit) {
      if (!utilities.isString(method) || !utilities.isFunction(adUnit[method])) {
        throw new VASTError('on VPAIDAdUnitWrapper.adUnitAsyncCall, invalid method name');
      }
  
      if (!utilities.isFunction(cb)) {
        throw new VASTError('on VPAIDAdUnitWrapper.adUnitAsyncCall, missing callback');
      }
    }
  
    function wrapCallback() {
      return function () {
        if (timeoutId) {
          clearTimeout(timeoutId);
        }
        cb.apply(this, arguments);
      };
    }
  };
  
  VPAIDAdUnitWrapper.prototype.on = function (evtName, handler) {
    var addEventListener = this._adUnit.addEventListener || this._adUnit.subscribe || this._adUnit.on;
  
    addEventListener.call(this._adUnit, evtName, handler);
  };
  
  VPAIDAdUnitWrapper.prototype.off = function (evtName, handler) {
    var removeEventListener = this._adUnit.removeEventListener || this._adUnit.unsubscribe || this._adUnit.off;
  
    removeEventListener.call(this._adUnit, evtName, handler);
  };
  
  VPAIDAdUnitWrapper.prototype.waitForEvent = function (evtName, cb, context) {
    var timeoutId = void 0;
  
    sanityCheck(evtName, cb);
    context = context || null;
  
    this.on(evtName, responseListener);
  
    timeoutId = setTimeout(function () {
      cb(new VASTError('on VPAIDAdUnitWrapper.waitForEvent, timeout while waiting for event \'' + evtName + '\''));
      timeoutId = null;
      cb = utilities.noop;
    }, this.options.responseTimeout);
  
    /** * Local functions ***/
    function sanityCheck(evtName, cb) {
      if (!utilities.isString(evtName)) {
        throw new VASTError('on VPAIDAdUnitWrapper.waitForEvent, missing evt name');
      }
  
      if (!utilities.isFunction(cb)) {
        throw new VASTError('on VPAIDAdUnitWrapper.waitForEvent, missing callback');
      }
    }
  
    function responseListener() {
      var args = utilities.arrayLikeObjToArray(arguments);
  
      if (timeoutId) {
        clearTimeout(timeoutId);
        timeoutId = null;
      }
  
      args.unshift(null);
      cb.apply(context, args);
    }
  };
  
  // VPAID METHODS
  VPAIDAdUnitWrapper.prototype.handshakeVersion = function (version, cb) {
    this.adUnitAsyncCall('handshakeVersion', version, cb);
  };
  
  /* jshint maxparams:6 */
  VPAIDAdUnitWrapper.prototype.initAd = function (width, height, viewMode, desiredBitrate, adUnitData, cb) {
    this.waitForEvent('AdLoaded', cb);
    this._adUnit.initAd(width, height, viewMode, desiredBitrate, adUnitData);
  };
  
  VPAIDAdUnitWrapper.prototype.resizeAd = function (width, height, viewMode, cb) {
    // NOTE: AdSizeChange event is only supported on VPAID 2.0 so for the moment we are not going to use it
    // and will assume that everything is fine after the async call
    this.adUnitAsyncCall('resizeAd', width, height, viewMode, cb);
  };
  
  VPAIDAdUnitWrapper.prototype.startAd = function (cb) {
    this.waitForEvent('AdStarted', cb);
    this._adUnit.startAd();
  };
  
  VPAIDAdUnitWrapper.prototype.stopAd = function (cb) {
    this.waitForEvent('AdStopped', cb);
    this._adUnit.stopAd();
  };
  
  VPAIDAdUnitWrapper.prototype.pauseAd = function (cb) {
    this.waitForEvent('AdPaused', cb);
    this._adUnit.pauseAd();
  };
  
  VPAIDAdUnitWrapper.prototype.resumeAd = function (cb) {
    this.waitForEvent('AdPlaying', cb);
    this._adUnit.resumeAd();
  };
  
  VPAIDAdUnitWrapper.prototype.expandAd = function (cb) {
    this.waitForEvent('AdExpandedChange', cb);
    this._adUnit.expandAd();
  };
  
  VPAIDAdUnitWrapper.prototype.collapseAd = function (cb) {
    this.waitForEvent('AdExpandedChange', cb);
    this._adUnit.collapseAd();
  };
  
  VPAIDAdUnitWrapper.prototype.skipAd = function (cb) {
    this.waitForEvent('AdSkipped', cb);
    this._adUnit.skipAd();
  };
  
  // VPAID property getters
  ['adLinear', 'adWidth', 'adHeight', 'adExpanded', 'adSkippableState', 'adRemainingTime', 'adDuration', 'adVolume', 'adCompanions', 'adIcons'].forEach(function (property) {
    var getterName = 'get' + utilities.capitalize(property);
  
    VPAIDAdUnitWrapper.prototype[getterName] = function (cb) {
      this.adUnitAsyncCall(getterName, cb);
    };
  });
  
  // VPAID property setters
  VPAIDAdUnitWrapper.prototype.setAdVolume = function (volume, cb) {
    this.adUnitAsyncCall('setAdVolume', volume, cb);
  };
  
  module.exports = VPAIDAdUnitWrapper;
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  __webpack_require__(49);
  var VPAIDFLASHClient = __webpack_require__(12);
  var MimeTypes = __webpack_require__(10);
  var VASTError = __webpack_require__(3);
  var utilities = __webpack_require__(0);
  var dom = __webpack_require__(6);
  var logger = __webpack_require__(5);
  
  function VPAIDFlashTech(mediaFile, settings) {
    if (!(this instanceof VPAIDFlashTech)) {
      return new VPAIDFlashTech(mediaFile);
    }
    sanityCheck(mediaFile);
    this.name = 'vpaid-flash';
    this.mediaFile = mediaFile;
    this.containerEl = null;
    this.vpaidFlashClient = null;
    this.settings = settings;
  
    /** * local functions ***/
    function sanityCheck(mediaFile) {
      if (!mediaFile || !utilities.isString(mediaFile.src)) {
        throw new VASTError('on VPAIDFlashTech, invalid MediaFile');
      }
    }
  }
  
  VPAIDFlashTech.VPAIDFLASHClient = VPAIDFLASHClient;
  
  VPAIDFlashTech.supports = function (type) {
    return MimeTypes.flash.indexOf(type) > -1 && VPAIDFlashTech.VPAIDFLASHClient.isSupported();
  };
  
  VPAIDFlashTech.prototype.loadAdUnit = function loadFlashCreative(containerEl, objectEl, callback) {
    var that = this;
    var flashClientOpts = this.settings && this.settings.vpaidFlashLoaderPath ? { data: this.settings.vpaidFlashLoaderPath } : undefined;
  
    sanityCheck(containerEl, callback);
  
    this.containerEl = containerEl;
  
    logger.debug('<VPAIDFlashTech.loadAdUnit> loading VPAIDFLASHClient with opts:', flashClientOpts);
  
    this.vpaidFlashClient = new VPAIDFlashTech.VPAIDFLASHClient(containerEl, function (error) {
      if (error) {
        return callback(error);
      }
  
      logger.info('<VPAIDFlashTech.loadAdUnit> calling VPAIDFLASHClient.loadAdUnit(); that.mediaFile:', that.mediaFile);
      that.vpaidFlashClient.loadAdUnit(that.mediaFile.src, callback);
    }, flashClientOpts);
  
    /** * Local Functions ***/
    function sanityCheck(container, cb) {
      if (!dom.isDomElement(container)) {
        throw new VASTError('on VPAIDFlashTech.loadAdUnit, invalid dom container element');
      }
  
      if (!utilities.isFunction(cb)) {
        throw new VASTError('on VPAIDFlashTech.loadAdUnit, missing valid callback');
      }
    }
  };
  
  VPAIDFlashTech.prototype.unloadAdUnit = function () {
    if (this.vpaidFlashClient) {
      try {
        this.vpaidFlashClient.destroy();
      } catch (e) {
        logger.error('VAST ERROR: trying to unload the VPAID adunit');
      }
      this.vpaidFlashClient = null;
    }
  
    if (this.containerEl) {
      dom.remove(this.containerEl);
      this.containerEl = null;
    }
  };
  
  module.exports = VPAIDFlashTech;
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var VPAIDHTML5Client = __webpack_require__(34);
  var MimeTypes = __webpack_require__(10);
  var VASTError = __webpack_require__(3);
  var utilities = __webpack_require__(0);
  var dom = __webpack_require__(6);
  var logger = __webpack_require__(5);
  
  function VPAIDHTML5Tech(mediaFile) {
    if (!(this instanceof VPAIDHTML5Tech)) {
      return new VPAIDHTML5Tech(mediaFile);
    }
  
    sanityCheck(mediaFile);
  
    this.name = 'vpaid-html5';
    this.containerEl = null;
    this.videoEl = null;
    this.vpaidHTMLClient = null;
  
    this.mediaFile = mediaFile;
  
    function sanityCheck(mediaFile) {
      if (!mediaFile || !utilities.isString(mediaFile.src)) {
        throw new VASTError(VPAIDHTML5Tech.INVALID_MEDIA_FILE);
      }
    }
  }
  
  VPAIDHTML5Tech.VPAIDHTML5Client = VPAIDHTML5Client;
  
  VPAIDHTML5Tech.supports = function (type) {
    return !utilities.isOldIE() && MimeTypes.html5.indexOf(type) > -1;
  };
  
  VPAIDHTML5Tech.prototype.loadAdUnit = function loadAdUnit(containerEl, videoEl, callback) {
    sanityCheck(containerEl, videoEl, callback);
  
    this.containerEl = containerEl;
    this.videoEl = videoEl;
    this.vpaidHTMLClient = new VPAIDHTML5Tech.VPAIDHTML5Client(containerEl, videoEl, {});
    this.vpaidHTMLClient.loadAdUnit(this.mediaFile.src, callback);
  
    function sanityCheck(container, video, cb) {
      if (!dom.isDomElement(container)) {
        throw new VASTError(VPAIDHTML5Tech.INVALID_DOM_CONTAINER_EL);
      }
  
      if (!dom.isDomElement(video) || video.tagName.toLowerCase() !== 'video') {
        throw new VASTError(VPAIDHTML5Tech.INVALID_DOM_CONTAINER_EL);
      }
  
      if (!utilities.isFunction(cb)) {
        throw new VASTError(VPAIDHTML5Tech.MISSING_CALLBACK);
      }
    }
  };
  
  VPAIDHTML5Tech.prototype.unloadAdUnit = function unloadAdUnit() {
    if (this.vpaidHTMLClient) {
      try {
        this.vpaidHTMLClient.destroy();
      } catch (e) {
        logger.error('VAST ERROR: trying to unload the VPAID adunit');
      }
  
      this.vpaidHTMLClient = null;
    }
  
    if (this.containerEl) {
      dom.remove(this.containerEl);
      this.containerEl = null;
    }
  };
  
  var PREFIX = 'on VPAIDHTML5Tech';
  
  VPAIDHTML5Tech.INVALID_MEDIA_FILE = PREFIX + ', invalid MediaFile';
  VPAIDHTML5Tech.INVALID_DOM_CONTAINER_EL = PREFIX + ', invalid container HtmlElement';
  VPAIDHTML5Tech.INVALID_DOM_VIDEO_EL = PREFIX + ', invalid HTMLVideoElement';
  VPAIDHTML5Tech.MISSING_CALLBACK = PREFIX + ', missing valid callback';
  
  module.exports = VPAIDHTML5Tech;
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var MimeTypes = __webpack_require__(10);
  var VASTError = __webpack_require__(3);
  var VASTResponse = __webpack_require__(8);
  var VASTTracker = __webpack_require__(20);
  var vastUtil = __webpack_require__(4);
  var async = __webpack_require__(9);
  var dom = __webpack_require__(6);
  var playerUtils = __webpack_require__(11);
  var utilities = __webpack_require__(0);
  var logger = __webpack_require__(5);
  var VPAIDAdUnitWrapper = __webpack_require__(40);
  
  function VPAIDIntegrator(player, settings) {
    if (!(this instanceof VPAIDIntegrator)) {
      return new VPAIDIntegrator(player);
    }
  
    this.VIEW_MODE = {
      NORMAL: 'normal',
      FULLSCREEN: 'fullscreen',
      THUMBNAIL: 'thumbnail'
    };
    this.player = player;
    this.containerEl = createVPAIDContainerEl(player);
    this.options = {
      responseTimeout: 5000,
      VPAID_VERSION: '2.0'
    };
    this.settings = settings;
  
    /** * Local functions ***/
  
    function createVPAIDContainerEl() {
      var containerEl = document.createElement('div');
  
      dom.addClass(containerEl, 'VPAID-container');
      player.el().insertBefore(containerEl, player.controlBar.el());
  
      return containerEl;
    }
  }
  
  VPAIDIntegrator.prototype.playAd = function playVPaidAd(vastResponse, callback) {
    if (!(vastResponse instanceof VASTResponse)) {
      return callback(new VASTError('on VASTIntegrator.playAd, missing required VASTResponse'));
    }
  
    var that = this;
    var player = this.player;
  
    logger.debug('<VPAIDIntegrator.playAd> looking for supported tech...');
    var tech = this._findSupportedTech(vastResponse, this.settings);
  
    callback = callback || utilities.noop;
  
    this._adUnit = null;
  
    dom.addClass(player.el(), 'vjs-vpaid-ad');
  
    player.on('vast.adsCancel', triggerVpaidAdEnd);
    player.one('vpaid.adEnd', function () {
      player.off('vast.adsCancel', triggerVpaidAdEnd);
      removeAdUnit();
    });
  
    if (tech) {
      logger.info('<VPAIDIntegrator.playAd> found tech: ', tech);
  
      async.waterfall([function (next) {
        next(null, tech, vastResponse);
      }, this._loadAdUnit.bind(this), this._playAdUnit.bind(this), this._finishPlaying.bind(this)], adComplete);
  
      this._adUnit = {
        _paused: true,
        type: 'VPAID',
        pauseAd: function pauseAd() {
          player.trigger('vpaid.pauseAd');
          player.pause(true); // we make sure that the video content gets stopped.
        },
        resumeAd: function resumeAd() {
          player.trigger('vpaid.resumeAd');
        },
        isPaused: function isPaused() {
          return this._paused;
        },
        getSrc: function getSrc() {
          return tech.mediaFile;
        }
      };
    } else {
      logger.debug('<VPAIDIntegrator.playAd> could not find suitable tech');
      var error = new VASTError('on VPAIDIntegrator.playAd, could not find a supported mediaFile', 403);
  
      adComplete(error, this._adUnit, vastResponse);
    }
  
    return this._adUnit;
  
    /** * Local functions ***/
    function adComplete(error, adUnit, vastResponse) {
      if (error && vastResponse) {
        that._trackError(vastResponse, error.code);
      }
      player.trigger('vpaid.adEnd');
      callback(error, vastResponse);
    }
  
    function triggerVpaidAdEnd() {
      player.trigger('vpaid.adEnd');
    }
  
    function removeAdUnit() {
      if (tech) {
        tech.unloadAdUnit();
      }
      dom.removeClass(player.el(), 'vjs-vpaid-ad');
    }
  };
  
  VPAIDIntegrator.prototype._findSupportedTech = function (vastResponse, settings) {
    if (!(vastResponse instanceof VASTResponse)) {
      return null;
    }
  
    var vpaidMediaFiles = vastResponse.mediaFiles.filter(vastUtil.isVPAID);
    var preferredTech = settings && settings.preferredTech;
    var skippedSupportTechs = [];
    var i = void 0,
        len = void 0,
        mediaFile = void 0,
        VPAIDTech = void 0,
        isPreferedTech = void 0;
  
    for (i = 0, len = vpaidMediaFiles.length; i < len; i += 1) {
      mediaFile = vpaidMediaFiles[i];
      VPAIDTech = vastUtil.findSupportedVPAIDTech(mediaFile.type);
  
      // no supported VPAID tech found, skip mediafile
      //eslint-disable-next-line
      if (!VPAIDTech) {
        continue;
      }
  
      // do we have a prefered tech, does it play this media file ?
      isPreferedTech = preferredTech ? mediaFile.type === preferredTech || MimeTypes[preferredTech] && MimeTypes[preferredTech].indexOf(mediaFile.type) > -1 : false;
  
      // our prefered tech can read this mediafile, defaulting to it.
      if (isPreferedTech) {
        return new VPAIDTech(mediaFile, settings);
      }
  
      skippedSupportTechs.push({ mediaFile: mediaFile, tech: VPAIDTech });
    }
  
    if (skippedSupportTechs.length) {
      var firstTech = skippedSupportTechs[0];
  
      return new firstTech.tech(firstTech.mediaFile, settings);
    }
  
    return null;
  };
  
  VPAIDIntegrator.prototype._createVPAIDAdUnitWrapper = function (adUnit, src, responseTimeout) {
    return new VPAIDAdUnitWrapper(adUnit, { src: src, responseTimeout: responseTimeout });
  };
  
  VPAIDIntegrator.prototype._loadAdUnit = function (tech, vastResponse, next) {
    var that = this;
    var player = this.player;
    var vjsTechEl = player.el().querySelector('.vjs-tech');
    var responseTimeout = this.settings.responseTimeout || this.options.responseTimeout;
  
    tech.loadAdUnit(this.containerEl, vjsTechEl, function (error, adUnit) {
      if (error) {
        return next(error, adUnit, vastResponse);
      }
  
      try {
        var WrappedAdUnit = that._createVPAIDAdUnitWrapper(adUnit, tech.mediaFile.src, responseTimeout);
        var techClass = 'vjs-' + tech.name + '-ad';
  
        dom.addClass(player.el(), techClass);
        player.one('vpaid.adEnd', function () {
          dom.removeClass(player.el(), techClass);
        });
        next(null, WrappedAdUnit, vastResponse);
      } catch (e) {
        next(e, adUnit, vastResponse);
      }
    });
  };
  
  VPAIDIntegrator.prototype._playAdUnit = function (adUnit, vastResponse, callback) {
    async.waterfall([function (next) {
      next(null, adUnit, vastResponse);
    }, this._handshake.bind(this), this._initAd.bind(this), this._setupEvents.bind(this), this._addSkipButton.bind(this), this._linkPlayerControls.bind(this), this._startAd.bind(this)], callback);
  };
  
  VPAIDIntegrator.prototype._handshake = function handshake(adUnit, vastResponse, next) {
    adUnit.handshakeVersion(this.options.VPAID_VERSION, function (error, version) {
      if (error) {
        return next(error, adUnit, vastResponse);
      }
  
      if (version && isSupportedVersion(version)) {
        return next(null, adUnit, vastResponse);
      }
  
      return next(new VASTError('on VPAIDIntegrator._handshake, unsupported version "' + version + '"'), adUnit, vastResponse);
    });
  
    function isSupportedVersion(version) {
      var majorNum = major(version);
  
      return majorNum >= 1 && majorNum <= 2;
    }
  
    function major(version) {
      var parts = version.split('.');
  
      return parseInt(parts[0], 10);
    }
  };
  
  VPAIDIntegrator.prototype._initAd = function (adUnit, vastResponse, next) {
    var tech = this.player.el().querySelector('.vjs-tech');
    var dimension = dom.getDimension(tech);
  
    adUnit.initAd(dimension.width, dimension.height, this.VIEW_MODE.NORMAL, -1, { AdParameters: vastResponse.adParameters || '' }, function (error) {
      next(error, adUnit, vastResponse);
    });
  };
  
  VPAIDIntegrator.prototype._createVASTTracker = function (adUnitSrc, vastResponse) {
    return new VASTTracker(adUnitSrc, vastResponse);
  };
  
  VPAIDIntegrator.prototype._setupEvents = function (adUnit, vastResponse, next) {
    var adUnitSrc = adUnit.options.src;
    var tracker = this._createVASTTracker(adUnitSrc, vastResponse);
    var player = this.player;
    var that = this;
  
    adUnit.on('AdSkipped', function () {
      player.trigger('vpaid.AdSkipped');
      tracker.trackSkip();
    });
  
    adUnit.on('AdImpression', function () {
      player.trigger('vpaid.AdImpression');
      tracker.trackImpressions();
    });
  
    adUnit.on('AdStarted', function () {
      player.trigger('vpaid.AdStarted');
      tracker.trackCreativeView();
      notifyPlayToPlayer();
    });
  
    adUnit.on('AdVideoStart', function () {
      player.trigger('vpaid.AdVideoStart');
      tracker.trackStart();
      notifyPlayToPlayer();
    });
  
    adUnit.on('AdPlaying', function () {
      player.trigger('vpaid.AdPlaying');
      tracker.trackResume();
      notifyPlayToPlayer();
    });
  
    adUnit.on('AdPaused', function () {
      player.trigger('vpaid.AdPaused');
      tracker.trackPause();
      notifyPauseToPlayer();
    });
  
    function notifyPlayToPlayer() {
      if (that._adUnit && that._adUnit.isPaused()) {
        that._adUnit._paused = false;
      }
      player.trigger('play');
    }
  
    function notifyPauseToPlayer() {
      if (that._adUnit) {
        that._adUnit._paused = true;
      }
      player.trigger('pause');
    }
  
    adUnit.on('AdVideoFirstQuartile', function () {
      player.trigger('vpaid.AdVideoFirstQuartile');
      tracker.trackFirstQuartile();
    });
  
    adUnit.on('AdVideoMidpoint', function () {
      player.trigger('vpaid.AdVideoMidpoint');
      tracker.trackMidpoint();
    });
  
    adUnit.on('AdVideoThirdQuartile', function () {
      player.trigger('vpaid.AdVideoThirdQuartile');
      tracker.trackThirdQuartile();
    });
  
    adUnit.on('AdVideoComplete', function () {
      player.trigger('vpaid.AdVideoComplete');
      tracker.trackComplete();
    });
  
    adUnit.on('AdClickThru', function (data) {
      player.trigger('vpaid.AdClickThru');
      var url = data.url;
      var playerHandles = data.playerHandles;
      var clickThruUrl = utilities.isNotEmptyString(url) ? url : generateClickThroughURL(vastResponse.clickThrough);
  
      tracker.trackClick();
      if (playerHandles && clickThruUrl) {
        window.open(clickThruUrl, '_blank');
      }
  
      function generateClickThroughURL(clickThroughMacro) {
        var variables = {
          ASSETURI: adUnit.options.src,
          CONTENTPLAYHEAD: 0 // In VPAID there is no method to know the current time from the adUnit
        };
  
        return clickThroughMacro ? vastUtil.parseURLMacro(clickThroughMacro, variables) : null;
      }
    });
  
    adUnit.on('AdUserAcceptInvitation', function () {
      player.trigger('vpaid.AdUserAcceptInvitation');
      tracker.trackAcceptInvitation();
      tracker.trackAcceptInvitationLinear();
    });
  
    adUnit.on('AdUserClose', function () {
      player.trigger('vpaid.AdUserClose');
      tracker.trackClose();
      tracker.trackCloseLinear();
    });
  
    adUnit.on('AdUserMinimize', function () {
      player.trigger('vpaid.AdUserMinimize');
      tracker.trackCollapse();
    });
  
    adUnit.on('AdError', function () {
      player.trigger('vpaid.AdError');
  
      // NOTE: we track errors code 901, as noted in VAST 3.0
      tracker.trackErrorWithCode(901);
    });
  
    adUnit.on('AdVolumeChange', function () {
      player.trigger('vpaid.AdVolumeChange');
      var lastVolume = player.volume();
  
      adUnit.getAdVolume(function (error, currentVolume) {
        if (lastVolume !== currentVolume) {
          if (currentVolume === 0 && lastVolume > 0) {
            tracker.trackMute();
          }
  
          if (currentVolume > 0 && lastVolume === 0) {
            tracker.trackUnmute();
          }
  
          player.volume(currentVolume);
        }
      });
    });
  
    var updateViewSize = resizeAd.bind(this, player, adUnit, this.VIEW_MODE);
    var updateViewSizeThrottled = utilities.throttle(updateViewSize, 100);
    var autoResize = this.settings.autoResize;
  
    if (autoResize) {
      dom.addEventListener(window, 'resize', updateViewSizeThrottled);
      dom.addEventListener(window, 'orientationchange', updateViewSizeThrottled);
    }
  
    player.on('vast.resize', updateViewSize);
    player.on('vpaid.pauseAd', pauseAdUnit);
    player.on('vpaid.resumeAd', resumeAdUnit);
  
    player.one('vpaid.adEnd', function () {
      player.off('vast.resize', updateViewSize);
      player.off('vpaid.pauseAd', pauseAdUnit);
      player.off('vpaid.resumeAd', resumeAdUnit);
  
      if (autoResize) {
        dom.removeEventListener(window, 'resize', updateViewSizeThrottled);
        dom.removeEventListener(window, 'orientationchange', updateViewSizeThrottled);
      }
    });
  
    next(null, adUnit, vastResponse);
  
    /** * Local Functions ***/
    function pauseAdUnit() {
      adUnit.pauseAd(utilities.noop);
    }
  
    function resumeAdUnit() {
      adUnit.resumeAd(utilities.noop);
    }
  };
  
  VPAIDIntegrator.prototype._addSkipButton = function (adUnit, vastResponse, next) {
    var skipButton = void 0;
    var player = this.player;
  
    adUnit.on('AdSkippableStateChange', updateSkipButtonState);
  
    playerUtils.once(player, ['vast.adEnd', 'vast.adsCancel'], removeSkipButton);
  
    next(null, adUnit, vastResponse);
  
    /** * Local function ***/
    function updateSkipButtonState() {
      player.trigger('vpaid.AdSkippableStateChange');
      adUnit.getAdSkippableState(function (error, isSkippable) {
        if (isSkippable) {
          if (!skipButton) {
            addSkipButton(player);
          }
        } else {
          removeSkipButton(player);
        }
      });
    }
  
    function addSkipButton(player) {
      skipButton = createSkipButton(player);
      player.el().appendChild(skipButton);
    }
  
    function removeSkipButton() {
      dom.remove(skipButton);
      skipButton = null;
    }
  
    function createSkipButton() {
      var skipButton = window.document.createElement('div');
  
      dom.addClass(skipButton, 'vast-skip-button');
      dom.addClass(skipButton, 'enabled');
      skipButton.innerHTML = 'Skip ad';
  
      skipButton.onclick = function (e) {
        adUnit.skipAd(utilities.noop); // We skip the adUnit
  
        // We prevent event propagation to avoid problems with the clickThrough and so on
        if (window.Event.prototype.stopPropagation === undefined) {
          return false;
        } else {
          e.stopPropagation();
        }
      };
  
      return skipButton;
    }
  };
  
  VPAIDIntegrator.prototype._linkPlayerControls = function (adUnit, vastResponse, next) {
    var that = this;
  
    linkVolumeControl(this.player, adUnit);
    linkFullScreenControl(this.player, adUnit, this.VIEW_MODE);
  
    next(null, adUnit, vastResponse);
  
    /** * Local functions ***/
    function linkVolumeControl(player, adUnit) {
      player.on('volumechange', updateAdUnitVolume);
      adUnit.on('AdVolumeChange', updatePlayerVolume);
  
      player.one('vpaid.adEnd', function () {
        player.off('volumechange', updateAdUnitVolume);
      });
  
      /** * local functions ***/
      function updateAdUnitVolume() {
        var vol = player.muted() ? 0 : player.volume();
  
        adUnit.setAdVolume(vol, logError);
      }
  
      function updatePlayerVolume() {
        player.trigger('vpaid.AdVolumeChange');
        var lastVolume = player.volume();
  
        adUnit.getAdVolume(function (error, vol) {
          if (error) {
            logError(error);
          } else if (lastVolume !== vol) {
            player.volume(vol);
          }
        });
      }
    }
  
    function linkFullScreenControl(player, adUnit, VIEW_MODE) {
      var updateViewSize = resizeAd.bind(that, player, adUnit, VIEW_MODE);
  
      player.on('fullscreenchange', updateViewSize);
  
      player.one('vpaid.adEnd', function () {
        player.off('fullscreenchange', updateViewSize);
      });
    }
  };
  
  VPAIDIntegrator.prototype._startAd = function (adUnit, vastResponse, next) {
    var player = this.player;
  
    adUnit.startAd(function (error) {
      if (!error) {
        player.trigger('vast.adStart');
      }
      next(error, adUnit, vastResponse);
    });
  };
  
  VPAIDIntegrator.prototype._finishPlaying = function (adUnit, vastResponse, next) {
    var player = this.player;
  
    adUnit.on('AdStopped', function () {
      player.trigger('vpaid.AdStopped');
      finishPlayingAd(null);
    });
  
    adUnit.on('AdError', function (error) {
      var errMsg = error ? error.message : 'on VPAIDIntegrator, error while waiting for the adUnit to finish playing';
  
      finishPlayingAd(new VASTError(errMsg));
    });
  
    /** * local functions ***/
    function finishPlayingAd(error) {
      next(error, adUnit, vastResponse);
    }
  };
  
  VPAIDIntegrator.prototype._trackError = function trackError(response, errorCode) {
    vastUtil.track(response.errorURLMacros, { ERRORCODE: errorCode || 901 });
  };
  
  function resizeAd(player, adUnit, VIEW_MODE) {
    var tech = player.el().querySelector('.vjs-tech');
    var dimension = dom.getDimension(tech);
    var MODE = player.isFullscreen() ? VIEW_MODE.FULLSCREEN : VIEW_MODE.NORMAL;
  
    adUnit.resizeAd(dimension.width, dimension.height, MODE, logError);
  }
  
  function logError(error) {
    if (error) {
      logger.error('ERROR: ' + error.message, error);
    }
  }
  
  module.exports = VPAIDIntegrator;
  
  /***/ }),
  /* 44 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var dom = __webpack_require__(6);
  
  var element = document.createElement('div');
  
  element.className = 'vjs-ads-label vjs-control vjs-label-hidden';
  element.innerHTML = 'Advertisement';
  
  var AdsLabelFactory = function AdsLabelFactory(baseComponent) {
    return {
      /** @constructor */
      init: function init(player, options) {
        options.el = element;
        baseComponent.call(this, player, options);
  
        // We asynchronously reposition the ads label element
        setTimeout(function () {
          var currentTimeComp = player.controlBar && (player.controlBar.getChild('timerControls') || player.controlBar.getChild('currentTimeDisplay'));
  
          if (currentTimeComp) {
            player.controlBar.el().insertBefore(element, currentTimeComp.el());
          }
          dom.removeClass(element, 'vjs-label-hidden');
        }, 0);
      },
  
      el: function getElement() {
        return element;
      }
    };
  };
  
  module.exports = AdsLabelFactory;
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  /**
   * The component that shows a black screen until the ads plugin has decided if it can or it can not play the ad.
   *
   * Note: In case you wonder why instead of this black poster we don't just show the spinner loader.
   *       IOS devices do not work well with animations and the browser chrashes from time to time That is why we chose to
   *       have a secondary black poster.
   *
   *       It also makes it much more easier for the users of the plugin since it does not change the default behaviour of the
   *       spinner and the player works the same way with and without the plugin.
   *
   * @param {vjs.Player|Object} player
   * @param {Object=} options
   * @constructor
   */
  var element = document.createElement('div');
  
  var BlackPosterFactory = function BlackPosterFactory(baseComponent) {
    return {
      /** @constructor */
      init: function init(player, options) {
        options.el = element;
        element.className = 'vjs-black-poster';
        baseComponent.call(this, player, options);
  
        var posterImg = player.getChild('posterImage');
  
        // We need to do it asynchronously to be sure that the black poster el is on the dom.
        setTimeout(function () {
          if (posterImg && player && player.el()) {
            player.el().insertBefore(element, posterImg.el());
          }
        }, 0);
      },
      el: function getElement() {
        return element;
      }
    };
  };
  
  module.exports = BlackPosterFactory;
  
  /***/ }),
  /* 46 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var urlUtils = __webpack_require__(24);
  var utilities = __webpack_require__(0);
  
  function HttpRequestError(message) {
    this.message = 'HttpRequest Error: ' + (message || '');
  }
  HttpRequestError.prototype = new Error();
  HttpRequestError.prototype.name = 'HttpRequest Error';
  
  function HttpRequest(createXhr) {
    if (!utilities.isFunction(createXhr)) {
      throw new HttpRequestError('Missing XMLHttpRequest factory method');
    }
  
    this.createXhr = createXhr;
  }
  
  HttpRequest.prototype.run = function (method, url, callback, options) {
    sanityCheck(url, callback, options);
    var timeout = void 0,
        timeoutId = void 0;
    var xhr = this.createXhr();
  
    options = options || {};
    timeout = utilities.isNumber(options.timeout) ? options.timeout : 0;
  
    xhr.open(method, urlUtils.urlParts(url).href, true);
  
    if (options.headers) {
      setHeaders(xhr, options.headers);
    }
  
    if (options.withCredentials) {
      xhr.withCredentials = true;
    }
  
    xhr.onload = function () {
      var statusText = void 0,
          response = void 0,
          status = void 0;
  
      /**
       * The only way to do a secure request on IE8 and IE9 is with the XDomainRequest object. Unfortunately, microsoft is
       * so nice that decided that the status property and the 'getAllResponseHeaders' method where not needed so we have to
       * fake them. If the request gets done with an XDomainRequest instance, we will assume that there are no headers and
       * the status will always be 200. If you don't like it, DO NOT USE ANCIENT BROWSERS!!!
       *
       * For mor info go to: https://msdn.microsoft.com/en-us/library/cc288060(v=vs.85).aspx
       */
      if (!xhr.getAllResponseHeaders) {
        xhr.getAllResponseHeaders = function () {
          return null;
        };
      }
  
      if (!xhr.status) {
        xhr.status = 200;
      }
  
      if (utilities.isDefined(timeoutId)) {
        clearTimeout(timeoutId);
        timeoutId = undefined;
      }
  
      statusText = xhr.statusText || '';
  
      // responseText is the old-school way of retrieving response (supported by IE8 & 9)
      // response/responseType properties were introduced in XHR Level2 spec (supported by IE10)
      response = 'response' in xhr ? xhr.response : xhr.responseText;
  
      // normalize IE9 bug (http://bugs.jquery.com/ticket/1450)
      status = xhr.status === 1223 ? 204 : xhr.status;
  
      callback(status, response, xhr.getAllResponseHeaders(), statusText);
    };
  
    xhr.onerror = requestError;
    xhr.onabort = requestError;
  
    xhr.send();
  
    if (timeout > 0) {
      timeoutId = setTimeout(function () {
        if (xhr) {
          xhr.abort();
        }
      }, timeout);
    }
  
    function sanityCheck(url, callback, options) {
      if (!utilities.isString(url) || utilities.isEmptyString(url)) {
        throw new HttpRequestError('Invalid url \'' + url + '\'');
      }
  
      if (!utilities.isFunction(callback)) {
        throw new HttpRequestError('Invalid handler \'' + callback + '\' for the http request');
      }
  
      if (utilities.isDefined(options) && !utilities.isObject(options)) {
        throw new HttpRequestError('Invalid options map \'' + options + '\'');
      }
    }
  
    function setHeaders(xhr, headers) {
      utilities.forEach(headers, function (value, key) {
        if (utilities.isDefined(value)) {
          xhr.setRequestHeader(key, value);
        }
      });
    }
  
    function requestError() {
      callback(-1, null, null, '');
    }
  };
  
  HttpRequest.prototype.get = function (url, callback, options) {
    this.run('GET', url, processResponse, options);
  
    function processResponse(status, response, headersString, statusText) {
      if (isSuccess(status)) {
        callback(null, response, status, headersString, statusText);
      } else {
        callback(new HttpRequestError(statusText), response, status, headersString, statusText);
      }
    }
  
    function isSuccess(status) {
      return 200 <= status && status < 300;
    }
  };
  
  function createXhr() {
    var xhr = new XMLHttpRequest();
  
    if (!('withCredentials' in xhr)) {
      // XDomainRequest for IE.
      xhr = new XDomainRequest();
    }
  
    return xhr;
  }
  
  var http = new HttpRequest(createXhr);
  
  module.exports = {
    http: http,
    HttpRequest: HttpRequest,
    HttpRequestError: HttpRequestError,
    createXhr: createXhr
  };
  
  /***/ }),
  /* 47 */
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(48)();
  // imports
  
  
  // module
  exports.push([module.i, ".vjs-label-hidden {\n  display: none !important;\n}\n\n.vjs-default-skin div.vjs-ads-label {\n  font-size: 13px;\n  line-height: 30px;\n  font-weight: normal;\n  text-align: center;\n  color: white;\n  display: none;\n  width: auto;\n  padding-left: 10px;\n}\n\n.vjs-ad-playing .vjs-control.vjs-ads-label {\n  display: block;\n}\n\n.vjs-black-poster {\n  position: absolute;\n  top: 0;\n  right: 0;\n  bottom: 0;\n  left: 0;\n  margin: 0;\n  padding: 0;\n  background-repeat: no-repeat;\n  background-position: 50% 50%;\n  background-size: contain;\n  cursor: pointer;\n  background-color: #000;\n}\n\n.vjs-has-started .vjs-black-poster.vjs-hidden {\n  display: none;\n}\n\n.vjs-using-native-controls .vjs-black-poster {\n  display: none;\n}\n\ndiv.VPAID-container {\n  position: absolute;\n  top: 0;\n  left: 0;\n  width: 100%;\n  height: 100%;\n}\n\ndiv.vjs-vpaid-ad div.vjs-progress-control,\ndiv.vjs-vpaid-ad div.vjs-time-controls,\ndiv.vjs-vpaid-ad div.vjs-time-divider {\n  display: none;\n}\n\ndiv.vjs-vpaid-ad.vjs-vpaid-flash-ad div.VPAID-container {\n  background-color: #000;\n}\n\ndiv.vjs-vpaid-ad .vjs-tech {\n  z-index: 0;\n}\n\n/**\n * videojs.ads.css\n */\n\n/* Ad playback */\n\n.vjs-ad-playing .vjs-progress-control {\n  pointer-events: none;\n}\n\n.vjs-ad-playing .vjs-play-control.vjs-paused,\n.vjs-ad-playing .vjs-volume-level,\n.vjs-ad-playing .vjs-play-progress {\n  background-color: #ffe400 !important;\n}\n\ndiv.vast-skip-button {\n  display: block;\n  position: absolute;\n  bottom: 20%;\n  right: 0;\n  background-color: #000;\n  color: white;\n  font-size: 15px;\n  font-weight: bold;\n  width: auto;\n  padding: 8px;\n  z-index: 2;\n  border: 1px solid white;\n  border-right: none;\n}\n\n.vast-skip-button.enabled {\n  cursor: pointer;\n  color: #fff;\n}\n\n.vast-skip-button.enabled:hover {\n  cursor: pointer;\n  background: #333;\n}\n\n.vast-blocker {\n  display: block;\n  position: absolute;\n  margin: 0;\n  padding: 0;\n  height: 100%;\n  width: 100%;\n  top: 0;\n  left: 0;\n  right: 0;\n  bottom: 0;\n}\n\n.vast-skip-button.enabled::after {\n  content: \">>\";\n  position: relative;\n  top: 1px;\n  margin-left: 8px;\n}\n\n/* Ad loading */\n\n.vjs-ad-playing.vjs-vast-ad-loading .vjs-loading-spinner {\n  display: block;\n  z-index: 10;\n  /* only animate when showing because it can be processor heavy */\n  -webkit-animation: spin 1.5s infinite linear;\n  animation: spin 1.5s infinite linear;\n}\n\n.vjs-vast-ad-loading div.vjs-big-play-button {\n  display: none !important;\n}\n\n.vjs-ad-playing .vjs-slider-handle::before {\n  display: none;\n}\n\n.vjs-ad-playing .vjs-live-controls {\n  display: none;\n}", ""]);
  
  // exports
  
  
  /***/ }),
  /* 48 */
  /***/ (function(module, exports) {
  
  /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  // css base code, injected by the css-loader
  module.exports = function() {
  	var list = [];
  
  	// return the list of modules as css string
  	list.toString = function toString() {
  		var result = [];
  		for(var i = 0; i < this.length; i++) {
  			var item = this[i];
  			if(item[2]) {
  				result.push("@media " + item[2] + "{" + item[1] + "}");
  			} else {
  				result.push(item[1]);
  			}
  		}
  		return result.join("");
  	};
  
  	// import a list of modules into the list
  	list.i = function(modules, mediaQuery) {
  		if(typeof modules === "string")
  			modules = [[null, modules, ""]];
  		var alreadyImportedModules = {};
  		for(var i = 0; i < this.length; i++) {
  			var id = this[i][0];
  			if(typeof id === "number")
  				alreadyImportedModules[id] = true;
  		}
  		for(i = 0; i < modules.length; i++) {
  			var item = modules[i];
  			// skip already imported module
  			// this implementation is not 100% perfect for weird media query combinations
  			//  when a module is imported multiple times with different media queries.
  			//  I hope this will never occur (Hey this way we have smaller bundles)
  			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
  				if(mediaQuery && !item[2]) {
  					item[2] = mediaQuery;
  				} else if(mediaQuery) {
  					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
  				}
  				list.push(item);
  			}
  		}
  	};
  	return list;
  };
  
  
  /***/ }),
  /* 49 */
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__.p + "VPAIDFlash.swf";
  
  /***/ }),
  /* 50 */
  /***/ (function(module, exports) {
  
  /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  var stylesInDom = {},
  	memoize = function(fn) {
  		var memo;
  		return function () {
  			if (typeof memo === "undefined") memo = fn.apply(this, arguments);
  			return memo;
  		};
  	},
  	isOldIE = memoize(function() {
  		return /msie [6-9]\b/.test(window.navigator.userAgent.toLowerCase());
  	}),
  	getHeadElement = memoize(function () {
  		return document.head || document.getElementsByTagName("head")[0];
  	}),
  	singletonElement = null,
  	singletonCounter = 0,
  	styleElementsInsertedAtTop = [];
  
  module.exports = function(list, options) {
  	if(typeof DEBUG !== "undefined" && DEBUG) {
  		if(typeof document !== "object") throw new Error("The style-loader cannot be used in a non-browser environment");
  	}
  
  	options = options || {};
  	// Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
  	// tags it will allow on a page
  	if (typeof options.singleton === "undefined") options.singleton = isOldIE();
  
  	// By default, add <style> tags to the bottom of <head>.
  	if (typeof options.insertAt === "undefined") options.insertAt = "bottom";
  
  	var styles = listToStyles(list);
  	addStylesToDom(styles, options);
  
  	return function update(newList) {
  		var mayRemove = [];
  		for(var i = 0; i < styles.length; i++) {
  			var item = styles[i];
  			var domStyle = stylesInDom[item.id];
  			domStyle.refs--;
  			mayRemove.push(domStyle);
  		}
  		if(newList) {
  			var newStyles = listToStyles(newList);
  			addStylesToDom(newStyles, options);
  		}
  		for(var i = 0; i < mayRemove.length; i++) {
  			var domStyle = mayRemove[i];
  			if(domStyle.refs === 0) {
  				for(var j = 0; j < domStyle.parts.length; j++)
  					domStyle.parts[j]();
  				delete stylesInDom[domStyle.id];
  			}
  		}
  	};
  }
  
  function addStylesToDom(styles, options) {
  	for(var i = 0; i < styles.length; i++) {
  		var item = styles[i];
  		var domStyle = stylesInDom[item.id];
  		if(domStyle) {
  			domStyle.refs++;
  			for(var j = 0; j < domStyle.parts.length; j++) {
  				domStyle.parts[j](item.parts[j]);
  			}
  			for(; j < item.parts.length; j++) {
  				domStyle.parts.push(addStyle(item.parts[j], options));
  			}
  		} else {
  			var parts = [];
  			for(var j = 0; j < item.parts.length; j++) {
  				parts.push(addStyle(item.parts[j], options));
  			}
  			stylesInDom[item.id] = {id: item.id, refs: 1, parts: parts};
  		}
  	}
  }
  
  function listToStyles(list) {
  	var styles = [];
  	var newStyles = {};
  	for(var i = 0; i < list.length; i++) {
  		var item = list[i];
  		var id = item[0];
  		var css = item[1];
  		var media = item[2];
  		var sourceMap = item[3];
  		var part = {css: css, media: media, sourceMap: sourceMap};
  		if(!newStyles[id])
  			styles.push(newStyles[id] = {id: id, parts: [part]});
  		else
  			newStyles[id].parts.push(part);
  	}
  	return styles;
  }
  
  function insertStyleElement(options, styleElement) {
  	var head = getHeadElement();
  	var lastStyleElementInsertedAtTop = styleElementsInsertedAtTop[styleElementsInsertedAtTop.length - 1];
  	if (options.insertAt === "top") {
  		if(!lastStyleElementInsertedAtTop) {
  			head.insertBefore(styleElement, head.firstChild);
  		} else if(lastStyleElementInsertedAtTop.nextSibling) {
  			head.insertBefore(styleElement, lastStyleElementInsertedAtTop.nextSibling);
  		} else {
  			head.appendChild(styleElement);
  		}
  		styleElementsInsertedAtTop.push(styleElement);
  	} else if (options.insertAt === "bottom") {
  		head.appendChild(styleElement);
  	} else {
  		throw new Error("Invalid value for parameter 'insertAt'. Must be 'top' or 'bottom'.");
  	}
  }
  
  function removeStyleElement(styleElement) {
  	styleElement.parentNode.removeChild(styleElement);
  	var idx = styleElementsInsertedAtTop.indexOf(styleElement);
  	if(idx >= 0) {
  		styleElementsInsertedAtTop.splice(idx, 1);
  	}
  }
  
  function createStyleElement(options) {
  	var styleElement = document.createElement("style");
  	styleElement.type = "text/css";
  	insertStyleElement(options, styleElement);
  	return styleElement;
  }
  
  function createLinkElement(options) {
  	var linkElement = document.createElement("link");
  	linkElement.rel = "stylesheet";
  	insertStyleElement(options, linkElement);
  	return linkElement;
  }
  
  function addStyle(obj, options) {
  	var styleElement, update, remove;
  
  	if (options.singleton) {
  		var styleIndex = singletonCounter++;
  		styleElement = singletonElement || (singletonElement = createStyleElement(options));
  		update = applyToSingletonTag.bind(null, styleElement, styleIndex, false);
  		remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true);
  	} else if(obj.sourceMap &&
  		typeof URL === "function" &&
  		typeof URL.createObjectURL === "function" &&
  		typeof URL.revokeObjectURL === "function" &&
  		typeof Blob === "function" &&
  		typeof btoa === "function") {
  		styleElement = createLinkElement(options);
  		update = updateLink.bind(null, styleElement);
  		remove = function() {
  			removeStyleElement(styleElement);
  			if(styleElement.href)
  				URL.revokeObjectURL(styleElement.href);
  		};
  	} else {
  		styleElement = createStyleElement(options);
  		update = applyToTag.bind(null, styleElement);
  		remove = function() {
  			removeStyleElement(styleElement);
  		};
  	}
  
  	update(obj);
  
  	return function updateStyle(newObj) {
  		if(newObj) {
  			if(newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap)
  				return;
  			update(obj = newObj);
  		} else {
  			remove();
  		}
  	};
  }
  
  var replaceText = (function () {
  	var textStore = [];
  
  	return function (index, replacement) {
  		textStore[index] = replacement;
  		return textStore.filter(Boolean).join('\n');
  	};
  })();
  
  function applyToSingletonTag(styleElement, index, remove, obj) {
  	var css = remove ? "" : obj.css;
  
  	if (styleElement.styleSheet) {
  		styleElement.styleSheet.cssText = replaceText(index, css);
  	} else {
  		var cssNode = document.createTextNode(css);
  		var childNodes = styleElement.childNodes;
  		if (childNodes[index]) styleElement.removeChild(childNodes[index]);
  		if (childNodes.length) {
  			styleElement.insertBefore(cssNode, childNodes[index]);
  		} else {
  			styleElement.appendChild(cssNode);
  		}
  	}
  }
  
  function applyToTag(styleElement, obj) {
  	var css = obj.css;
  	var media = obj.media;
  
  	if(media) {
  		styleElement.setAttribute("media", media)
  	}
  
  	if(styleElement.styleSheet) {
  		styleElement.styleSheet.cssText = css;
  	} else {
  		while(styleElement.firstChild) {
  			styleElement.removeChild(styleElement.firstChild);
  		}
  		styleElement.appendChild(document.createTextNode(css));
  	}
  }
  
  function updateLink(linkElement, obj) {
  	var css = obj.css;
  	var sourceMap = obj.sourceMap;
  
  	if(sourceMap) {
  		// http://stackoverflow.com/a/26603875
  		css += "\n/*# sourceMappingURL=data:application/json;base64," + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + " */";
  	}
  
  	var blob = new Blob([css], { type: "text/css" });
  
  	var oldSrc = linkElement.href;
  
  	linkElement.href = URL.createObjectURL(blob);
  
  	if(oldSrc)
  		URL.revokeObjectURL(oldSrc);
  }
  
  
  /***/ }),
  /* 51 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var baseVideoJsComponent = videojs.Component;
  
  var AdsLabel = __webpack_require__(44)(baseVideoJsComponent);
  
  videojs.AdsLabel = videojs.Component.extend(AdsLabel);
  
  /***/ }),
  /* 52 */,
  /* 53 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var baseVideoJsComponent = videojs.Component;
  
  var BlackPoster = __webpack_require__(45)(baseVideoJsComponent);
  
  videojs.BlackPoster = videojs.Component.extend(BlackPoster);
  
  /***/ }),
  /* 54 */,
  /* 55 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  __webpack_require__(51);
  __webpack_require__(53);
  __webpack_require__(27);
  
  var videoJsVAST = __webpack_require__(26);
  
  videojs.plugin('vastClient', videoJsVAST);
  
  /***/ })
  /******/ ]);
  });
  //# sourceMappingURL=videojs_4.vast.vpaid.js.map