prebid-universal-creative 1.17.1 → 1.18.0

package/dist/main.max.js

@@ -0,0 +1,3172 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ([
+/* 0 */,
+/* 1 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.createTrackPixelHtml = createTrackPixelHtml;
+exports.getCreativeComment = getCreativeComment;
+exports.getCreativeCommentMarkup = getCreativeCommentMarkup;
+exports.getUUID = getUUID;
+exports.loadScript = loadScript;
+exports.parseUrl = parseUrl;
+exports.sendRequest = sendRequest;
+exports.transformAuctionTargetingData = transformAuctionTargetingData;
+exports.triggerPixel = triggerPixel;
+exports.writeAdUrl = writeAdUrl;
+var domHelper = _interopRequireWildcard(__webpack_require__(2));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t2 in e) { "default" !== _t2 && {}.hasOwnProperty.call(e, _t2) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t2)) && (i.get || i.set) ? o(f, _t2, i) : f[_t2] = e[_t2]); } return f; })(e, t); }
+/**
+ * Inserts an image pixel with the specified `url` for cookie sync
+ * @param {string} url URL string of the image pixel to load
+ * @param  {function} [done] an optional exit callback, used when this usersync pixel is added during an async process
+ */
+function triggerPixel(url, done) {
+  var img = new Image();
+  if (done && typeof done === 'function') {
+    img.addEventListener('load', done);
+    img.addEventListener('error', done);
+  }
+  img.src = url;
+}
+function createTrackPixelHtml(url) {
+  if (!url) {
+    return '';
+  }
+  var escapedUrl = encodeURI(url);
+  var img = "<div style=\"position:absolute;left:0px;top:0px;visibility:hidden;\"><img src=\"".concat(escapedUrl, "\"></div>");
+  return img;
+}
+function writeAdUrl(adUrl, width, height) {
+  var iframe = domHelper.getEmptyIframe(height, width);
+  iframe.src = adUrl;
+  document.body.appendChild(iframe);
+}
+function sendRequest(url, callback) {
+  function reqListener() {
+    callback(oReq.responseText);
+  }
+  var oReq = new XMLHttpRequest();
+  oReq.addEventListener('load', reqListener);
+  oReq.open('GET', url);
+  oReq.send();
+}
+function getUUID() {
+  var d = new Date().getTime();
+  var uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    var r = (d + Math.random() * 16) % 16 | 0;
+    d = Math.floor(d / 16);
+    return (c === 'x' ? r : r & 0x3 | 0x8).toString(16);
+  });
+  return uuid;
+}
+;
+function loadScript(currentWindow, tagSrc, successCallback, errorCallback) {
+  var doc = currentWindow.document;
+  var scriptTag = doc.createElement('script');
+  scriptTag.type = 'text/javascript';
+
+  // Execute success callback if necessary
+  if (successCallback && typeof successCallback === 'function') {
+    if (scriptTag.readyState) {
+      scriptTag.onreadystatechange = function () {
+        if (scriptTag.readyState === 'loaded' || scriptTag.readyState === 'complete') {
+          scriptTag.onreadystatechange = null;
+          successCallback();
+        }
+      };
+    } else {
+      scriptTag.onload = function () {
+        successCallback();
+      };
+    }
+  }
+
+  // Execute error callback if necessary
+  if (errorCallback && typeof errorCallback === 'function') {
+    scriptTag.onerror = function () {
+      errorCallback();
+    };
+  }
+  scriptTag.src = tagSrc;
+
+  //add the new script tag to the page
+  var elToAppend = doc.getElementsByTagName('head');
+  elToAppend = elToAppend.length ? elToAppend : doc.getElementsByTagName('body');
+  if (elToAppend.length) {
+    elToAppend = elToAppend[0];
+    elToAppend.insertBefore(scriptTag, elToAppend.firstChild);
+  }
+  return scriptTag;
+}
+;
+
+/**
+ * Return comment element
+ * @param {*} bid
+ */
+function getCreativeComment(bid) {
+  return document.createComment("Creative ".concat(bid.crid, " served by Prebid.js Header Bidding"));
+}
+
+/**
+ * Returns comment element markup
+ * @param {*} bid
+ */
+function getCreativeCommentMarkup(bid) {
+  var creativeComment = getCreativeComment(bid);
+  var wrapper = document.createElement('div');
+  wrapper.appendChild(creativeComment);
+  return wrapper.innerHTML;
+}
+function transformAuctionTargetingData(tagData) {
+  // this map object translates the Prebid.js auction keys to their equivalent Prebid Universal Creative keys
+  // when the publisher uses their adserver's generic macro that provides all targeting keys (ie tagData.targetingMap), we need to convert the keys
+  var auctionKeyMap = {
+    hb_adid: 'adId',
+    hb_cache_host: 'cacheHost',
+    hb_cache_path: 'cachePath',
+    hb_cache_id: 'uuid',
+    hb_format: 'mediaType',
+    hb_env: 'env',
+    hb_size: 'size',
+    hb_pb: 'hbPb'
+  };
+
+  /**
+   * Determine if the supplied property of the tagData object exists and is populated with its own values/properties according to its type
+   * @param {string} paramName name of the property to check (eg tagData.targetingMap)
+   * @returns true/false
+   */
+  function isMacroPresent(paramName) {
+    return !!(tagData[paramName] && (isPlainObject(tagData[paramName]) && Object.keys(tagData[paramName]).length > 0 || isStr(tagData[paramName]) && tagData[paramName] !== ''));
+  }
+
+  /**
+   * Converts the specifically formatted object of keypairs to a more generalized structure
+   * It specifically extracts the keyvalue from an array and stores it as a normal string
+   * @param {object} tarMap object of keys with the keyvalue stored in an array; eg {"hb_adid":["26566ee8c7f251"], ...}
+   * @returns {object} result is an object map like the following: {"hb_cache_id":"123456", "other_key":"other_value", ...}
+   */
+  function convertTargetingMapToNormalMap(tarMap) {
+    var newTarMap = {};
+    Object.keys(tarMap).forEach(function (key) {
+      if (Array.isArray(tarMap[key]) && tarMap[key].length > 0) {
+        newTarMap[key] = tarMap[key][0];
+      }
+    });
+    return newTarMap;
+  }
+
+  /**
+   * Converts a specifically formatted string of keypairs to a specifically formatted object map
+   * @param {String} keywordsStr string of keypairs; eg "hb_cache_id:123456,other_key:other_value"
+   * @returns {object} result is an object map like the following: {"hb_cache_id":"123456", "other_key":"other_value", ...}
+   */
+  function convertKeyPairStringToMap(keywordsStr) {
+    var keywordsMap = {};
+    var keywordsArr = keywordsStr.split(',');
+    if (keywordsArr.length > 0) {
+      keywordsArr.forEach(function (keyPairStr) {
+        var keyPairArr = keyPairStr.split(':');
+        if (keyPairArr.length === 2) {
+          var k = keyPairArr[0];
+          var v = keyPairArr[1];
+          keywordsMap[k] = v;
+        }
+      });
+    }
+    return keywordsMap;
+  }
+
+  /**
+   * Rename key if it's part of the auctionKeyMap object; if not, leave key as is
+   * Store the resultant keypair in the auctionData object for later use in renderingManager.renderAd()
+   * @param {object} adServerKeyMap incoming object map of the auction keys from the UC tag; eg {'key1':'value1', 'key2':'value2', ...}
+   */
+  function renameKnownAuctionKeys(adServerKeyMap) {
+    Object.keys(adServerKeyMap).forEach(function (key) {
+      var internalKey = auctionKeyMap[key] || key;
+      auctionData[internalKey] = adServerKeyMap[key];
+    });
+  }
+  var auctionData = {};
+  var formattedKeyMap = {};
+  if (isMacroPresent('targetingMap')) {
+    formattedKeyMap = convertTargetingMapToNormalMap(tagData.targetingMap);
+  } else if (isMacroPresent('targetingKeywords')) {
+    formattedKeyMap = convertKeyPairStringToMap(tagData.targetingKeywords);
+  }
+  renameKnownAuctionKeys(formattedKeyMap);
+
+  // set keys not in defined map macros (eg targetingMap) and/or the keys setup within a non-DFP adserver
+  Object.keys(tagData).forEach(function (key) {
+    if (key !== 'targetingMap' && key !== 'targetingKeywords' && isStr(tagData[key]) && tagData[key] !== '') {
+      auctionData[key] = tagData[key];
+    }
+  });
+  return auctionData;
+}
+function parseUrl(url) {
+  var parsed = document.createElement('a');
+  parsed.href = decodeURIComponent(url);
+  return {
+    href: parsed.href,
+    protocol: (parsed.protocol || '').replace(/:$/, ''),
+    hostname: parsed.hostname,
+    port: +parsed.port,
+    pathname: parsed.pathname.replace(/^(?!\/)/, '/'),
+    hash: (parsed.hash || '').replace(/^#/, ''),
+    host: (parsed.host || window.location.host).replace(/:(443|80)$/, '')
+  };
+}
+function isA(object, _t) {
+  return Object.prototype.toString.call(object) === '[object ' + _t + ']';
+}
+;
+function isPlainObject(object) {
+  return isA(object, 'Object');
+}
+function isStr(object) {
+  return isA(object, 'String');
+}
+;
+
+/***/ }),
+/* 2 */
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.getEmptyIframe = getEmptyIframe;
+exports.insertElement = insertElement;
+exports.makeIframe = makeIframe;
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) { ; } } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) { ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } } return n; }, _extends.apply(null, arguments); }
+/**
+ * domHelper: a collection of helpful dom things
+ */
+
+/**
+ * returns a empty iframe element with specified attributes.
+ */
+function makeIframe(doc) {
+  var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var frame = doc.createElement('iframe');
+  Object.entries(_extends({
+    frameborder: 0,
+    scrolling: 'no',
+    marginheight: 0,
+    marginwidth: 0,
+    TOPMARGIN: 0,
+    LEFTMARGIN: 0,
+    allowtransparency: 'true'
+  }, attrs)).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      attr = _ref2[0],
+      value = _ref2[1];
+    frame.setAttribute(attr, value);
+  });
+  return frame;
+}
+
+/**
+ * returns a empty iframe element with specified height/width
+ * @param {Number} height height iframe set to
+ * @param {Number} width width iframe set to
+ * @returns {Element} iframe DOM element
+ */
+function getEmptyIframe(height, width) {
+  return makeIframe(document, {
+    height: height,
+    width: width
+  });
+}
+
+/**
+* Insert element to passed target
+* @param {object} elm
+* @param {object} doc
+* @param {string} target
+*/
+function insertElement(elm, doc, target) {
+  doc = doc || document;
+  var elToAppend;
+  if (target) {
+    elToAppend = doc.getElementsByTagName(target);
+  } else {
+    elToAppend = doc.getElementsByTagName('head');
+  }
+  try {
+    elToAppend = elToAppend.length ? elToAppend : doc.getElementsByTagName('body');
+    if (elToAppend.length) {
+      elToAppend = elToAppend[0];
+      elToAppend.insertBefore(elm, elToAppend.firstChild);
+    }
+  } catch (e) {}
+}
+
+/***/ }),
+/* 3 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.renderBannerOrDisplayAd = renderBannerOrDisplayAd;
+exports.renderCrossDomain = renderCrossDomain;
+exports.renderLegacy = renderLegacy;
+var _utils = __webpack_require__(1);
+var _environment = __webpack_require__(4);
+var _domHelper = __webpack_require__(2);
+var _messaging = __webpack_require__(5);
+var _dynamicRenderer = __webpack_require__(6);
+function renderBannerOrDisplayAd(doc, dataObject) {
+  var targetingData = (0, _utils.transformAuctionTargetingData)(dataObject);
+  if (!(0, _environment.canLocatePrebid)(window)) {
+    renderCrossDomain(window, targetingData.adId, targetingData.adServerDomain, targetingData.pubUrl);
+  } else {
+    renderLegacy(doc, targetingData.adId);
+  }
+}
+
+/**
+ * Calls prebid.js renderAd function to render ad
+ * @param {Object} doc Document
+ * @param {string} adId Id of creative to render
+ */
+function renderLegacy(doc, adId) {
+  var found = false;
+  var w = window;
+  for (var i = 0; i < 10; i++) {
+    w = w.parent;
+    if (w.pbjs) {
+      try {
+        w.pbjs.renderAd(doc, adId);
+        found = true;
+        break;
+      } catch (e) {
+        continue;
+      }
+    }
+  }
+  if (!found) {
+    console.error("Unable to locate pbjs.renderAd function!");
+  }
+}
+
+/**
+ * Render ad in safeframe using postmessage
+ * @param {string} adId Id of creative to render
+ * @param {string} pubAdServerDomain publisher adserver domain name
+ * @param {string} pubUrl Url of publisher page
+ */
+function renderCrossDomain(win, adId) {
+  var pubAdServerDomain = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var pubUrl = arguments.length > 3 ? arguments[3] : undefined;
+  var windowLocation = win.location;
+  var adServerDomain = pubAdServerDomain || win.location.hostname;
+  var fullAdServerDomain = windowLocation.protocol + '//' + adServerDomain;
+  var sendMessage = (0, _messaging.prebidMessenger)(pubUrl, win);
+  var signalRenderResult = function signalRenderResult(errorInfo) {
+    return sendMessage((0, _messaging.renderEventMessage)(adId, errorInfo));
+  };
+  function renderAd(ev) {
+    var key = ev.message ? "message" : "data";
+    var adObject = {};
+    try {
+      adObject = JSON.parse(ev[key]);
+    } catch (e) {
+      return;
+    }
+    if (adObject.message && adObject.message === "Prebid Response" && adObject.adId === adId) {
+      if ((0, _dynamicRenderer.hasDynamicRenderer)(adObject)) {
+        (0, _dynamicRenderer.runDynamicRenderer)(adId, adObject, sendMessage, win);
+        return;
+      }
+      try {
+        var body = win.document.body;
+        var ad = adObject.ad;
+        var url = adObject.adUrl;
+        var width = adObject.width;
+        var height = adObject.height;
+        if (adObject.mediaType === "video") {
+          signalRenderResult({
+            reason: "preventWritingOnMainDocument",
+            message: "Cannot render video ad ".concat(adId)
+          });
+          console.log("Error trying to write ad.");
+        } else if (ad) {
+          var iframe = (0, _domHelper.getEmptyIframe)(adObject.height, adObject.width);
+          body.appendChild(iframe);
+          iframe.contentDocument.open();
+          iframe.contentDocument.write(ad);
+          iframe.contentDocument.close();
+          signalRenderResult();
+        } else if (url) {
+          var _iframe = (0, _domHelper.getEmptyIframe)(height, width);
+          _iframe.style.display = "inline";
+          _iframe.style.overflow = "hidden";
+          _iframe.src = url;
+          (0, _domHelper.insertElement)(_iframe, document, "body");
+          signalRenderResult();
+        } else {
+          signalRenderResult({
+            reason: "noAd",
+            message: "No ad for ".concat(adId)
+          });
+          console.log("Error trying to write ad. No ad markup or adUrl for ".concat(adId));
+        }
+      } catch (e) {
+        signalRenderResult({
+          reason: "exception",
+          message: e.message
+        });
+        console.log("Error in rendering ad", e);
+      }
+    }
+  }
+  function requestAdFromPrebid() {
+    var message = {
+      message: 'Prebid Request',
+      adId: adId,
+      adServerDomain: fullAdServerDomain
+    };
+    sendMessage(message, renderAd);
+  }
+  requestAdFromPrebid();
+}
+
+/***/ }),
+/* 4 */
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.canInspectWindow = canInspectWindow;
+exports.canLocatePrebid = canLocatePrebid;
+exports.isAmp = isAmp;
+exports.isCrossDomain = isCrossDomain;
+exports.isMobileApp = isMobileApp;
+exports.isSafeFrame = isSafeFrame;
+/***************************************
+ * Detect Environment Helper Functions
+ ***************************************/
+
+/**
+ * Functions to detect below environments:
+ *  Amp: google Accelerate Mobile Pages ampproject.org
+ *  SafeFrame: SafeFrame
+ *  CrossDomain: An iframe that can't get to the top window
+ *  Mobile App: function to detect mobile app environment
+ */
+
+/**
+ * @param {String} uuid key value from auction, contains the cache id of the winning bid stored in prebid cache
+ * @returns true if there is an AMP context object
+ */
+function isAmp(uuid, win) {
+  // TODO Use amp context once it is available in cross domain
+  // https://github.com/ampproject/amphtml/issues/6829
+  return typeof uuid === 'string' && uuid !== "" && isCrossDomain(win);
+}
+
+/**
+ * @returns true if the environment is a SafeFrame.
+ */
+function isSafeFrame(win) {
+  return !!(win.$sf && win.$sf.ext);
+}
+
+/**
+  * Return true if we are in an iframe and can't access the top window.
+  * @returns true if the environment is a Cross Domain
+  */
+function isCrossDomain(win) {
+  return win.top !== win && !canInspectWindow(win);
+}
+
+/**
+ * Returns true if win's properties can be accessed and win is defined.
+ * This functioned is used to determine if a window is cross-domained
+ * from the perspective of the current window.
+ * @param {!Window} win
+ * @return {boolean}
+ */
+function canInspectWindow(win) {
+  try {
+    // force an exception in x-domain environments. #1509
+    win.top.location.toString();
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * Returns true if we can find the prebid global object (eg pbjs) as we
+ * climb the accessible windows.  Return false if it's not found.
+ * @returns {boolean}
+ */
+function canLocatePrebid(win) {
+  var result = false;
+  var currentWindow = win;
+  while (!result) {
+    try {
+      if (currentWindow.pbjs) {
+        result = true;
+        break;
+      }
+    } catch (e) {}
+    if (currentWindow === window.top) break;
+    currentWindow = currentWindow.parent;
+  }
+  return result;
+}
+
+/**
+ * @param {String} env key value from auction, indicates the environment where tag is served
+ * @returns true if env exists and is equal to the string 'mobile-app'
+ */
+function isMobileApp(env) {
+  return env && env === 'mobile-app';
+}
+
+/***/ }),
+/* 5 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.PREBID_EVENT = exports.AD_RENDER_SUCCEEDED = exports.AD_RENDER_FAILED = void 0;
+exports.prebidMessenger = prebidMessenger;
+exports.renderEventMessage = renderEventMessage;
+var _utils = __webpack_require__(1);
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) { ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } } return n; }, _extends.apply(null, arguments); }
+var PREBID_EVENT = exports.PREBID_EVENT = 'Prebid Event';
+var AD_RENDER_SUCCEEDED = exports.AD_RENDER_SUCCEEDED = 'adRenderSucceeded';
+var AD_RENDER_FAILED = exports.AD_RENDER_FAILED = 'adRenderFailed';
+function prebidMessenger(publisherURL) {
+  var win = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : window;
+  var prebidDomain = function () {
+    if (publisherURL == null) {
+      return null;
+    }
+    var parsedUrl = (0, _utils.parseUrl)(publisherURL);
+    return parsedUrl.protocol + '://' + parsedUrl.host;
+  }();
+  function isPrebidWindow(win) {
+    return win && win.frames && win.frames.__pb_locator__;
+  }
+  var target = win.parent;
+  try {
+    while (target != null && target !== win.top && !isPrebidWindow(target)) {
+      target = target.parent;
+    }
+    if (!isPrebidWindow(target)) target = win.parent;
+  } catch (e) {}
+  return function sendMessage(message, onResponse) {
+    if (prebidDomain == null) {
+      throw new Error('Missing pubUrl');
+    }
+    message = JSON.stringify(message);
+    var messagePort;
+    if (onResponse == null) {
+      target.postMessage(message, prebidDomain);
+    } else {
+      var channel = new MessageChannel();
+      messagePort = channel.port1;
+      messagePort.onmessage = onResponse;
+      win.addEventListener('message', windowListener);
+      target.postMessage(message, prebidDomain, [channel.port2]);
+    }
+    return function stopListening() {
+      if (messagePort != null) {
+        win.removeEventListener('message', windowListener);
+        messagePort.onmessage = null;
+        messagePort = null;
+      }
+    };
+    function windowListener(ev) {
+      if ((ev.origin || ev.originalEvent && ev.originalEvent.origin) === prebidDomain) {
+        onResponse(ev);
+      }
+    }
+  };
+}
+function renderEventMessage(adId, errorInfo) {
+  return _extends({
+    adId: adId,
+    message: PREBID_EVENT,
+    event: errorInfo ? AD_RENDER_FAILED : AD_RENDER_SUCCEEDED
+  }, errorInfo ? {
+    info: errorInfo
+  } : null);
+}
+
+/***/ }),
+/* 6 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.MIN_RENDERER_VERSION = void 0;
+exports.hasDynamicRenderer = hasDynamicRenderer;
+exports.runDynamicRenderer = runDynamicRenderer;
+var _domHelper = __webpack_require__(2);
+var _messaging = __webpack_require__(5);
+function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) { ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } } return n; }, _extends.apply(null, arguments); }
+var MIN_RENDERER_VERSION = exports.MIN_RENDERER_VERSION = 3;
+function hasDynamicRenderer(message) {
+  return typeof message.renderer === 'string' && parseInt(message.rendererVersion, 10) >= MIN_RENDERER_VERSION;
+}
+function runDynamicRenderer(adId, data, _sendMessage) {
+  var win = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : window;
+  var mkFrame = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _domHelper.makeIframe;
+  var renderer = mkFrame(win.document, {
+    width: 0,
+    height: 0,
+    style: 'display: none',
+    srcdoc: "<script>".concat(data.renderer, "</script>"),
+    name: '__pb_renderer__'
+  });
+  return new Promise(function (resolve, reject) {
+    function onError() {
+      var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      _sendMessage((0, _messaging.renderEventMessage)(adId, {
+        reason: e.reason || 'exception',
+        message: e.message
+      }));
+      e.stack && console.error(e);
+      reject(e);
+    }
+    function guard(fn) {
+      return function () {
+        try {
+          return fn.apply(this, arguments);
+        } catch (e) {
+          onError(e);
+        }
+      };
+    }
+    renderer.onload = guard(function () {
+      var W = renderer.contentWindow;
+      // NOTE: on Firefox, `Promise.resolve(P)` or `new Promise((resolve) => resolve(P))`
+      // does not appear to work if P comes from another frame
+      W.Promise.resolve(W.render(data, {
+        mkFrame: mkFrame,
+        sendMessage: function sendMessage(type, payload, onResponse) {
+          return _sendMessage(_extends({
+            adId: adId,
+            message: type
+          }, payload), onResponse ? guard(onResponse) : undefined);
+        }
+      }, win)).then(function () {
+        return _sendMessage((0, _messaging.renderEventMessage)(adId));
+      }, onError).then(resolve);
+    });
+    win.document.body.appendChild(renderer);
+  });
+}
+
+/***/ }),
+/* 7 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.renderAmpOrMobileAd = renderAmpOrMobileAd;
+var _utils = __webpack_require__(1);
+var _environment = __webpack_require__(4);
+var _domHelper = __webpack_require__(2);
+var _postscribeRender = __webpack_require__(8);
+var DEFAULT_CACHE_HOST = 'prebid.adnxs.com';
+var DEFAULT_CACHE_PATH = '/pbc/v1/cache';
+
+/**
+ * Render mobile or amp ad
+ * @param {string} cacheHost Cache host
+ * @param {string} cachePath Cache path
+ * @param {string} uuid id to render response from cache endpoint
+ * @param {string} size size of the creative
+ * @param {string} hbPb final price of the winning bid
+ * @param {Bool} isMobileApp flag to detect mobile app
+ */
+function renderAmpOrMobileAd(dataObject) {
+  var targetingData = (0, _utils.transformAuctionTargetingData)(dataObject);
+  var cacheHost = targetingData.cacheHost,
+    cachePath = targetingData.cachePath,
+    uuid = targetingData.uuid,
+    size = targetingData.size,
+    hbPb = targetingData.hbPb;
+  uuid = uuid || '';
+  // For MoPub, creative is stored in localStorage via SDK.
+  var search = 'Prebid_';
+  if (uuid.substr(0, search.length) === search) {
+    loadFromLocalCache(uuid);
+    //register creative right away to not miss initial geom-update
+    updateIframe(size);
+  } else {
+    var adUrl = "".concat(getCacheEndpoint(cacheHost, cachePath), "?uuid=").concat(uuid);
+    //register creative right away to not miss initial geom-update
+    updateIframe(size);
+    (0, _utils.sendRequest)(adUrl, responseCallback((0, _environment.isMobileApp)(targetingData.env), hbPb));
+  }
+}
+
+/**
+ * Load response from localStorage. In case of MoPub, sdk caches response
+ * @param {string} cacheId
+ */
+function loadFromLocalCache(cacheId) {
+  var bid = window.localStorage.getItem(cacheId);
+  var displayFn = responseCallback(true);
+  displayFn(bid);
+}
+
+/**
+ * update iframe by using size string to resize
+ * @param {string} size
+ */
+function updateIframe(size) {
+  if (size) {
+    var sizeArr = size.split('x').map(Number);
+    resizeIframe(sizeArr[0], sizeArr[1]);
+  } else {
+    console.log('Targeting key hb_size not found to resize creative');
+  }
+}
+
+/**
+ * Resize container iframe
+ * @param {Number} width width of creative
+ * @param {Number} height height of creative
+ */
+function resizeIframe(width, height) {
+  var iframeWidth = window.innerWidth;
+  var iframeHeight = window.innerHeight;
+  if (iframeWidth !== width || iframeHeight !== height) {
+    if ((0, _environment.isSafeFrame)(window)) {
+      var resize = function resize() {
+        var newWidth = width - iframeWidth;
+        var newHeight = height - iframeHeight;
+        window.$sf.ext.expand({
+          r: newWidth,
+          b: newHeight,
+          push: true
+        });
+      };
+      window.$sf.ext.register(width, height, resize);
+    }
+    // AMP resize request in case the parent is AMP
+    window.parent.postMessage({
+      sentinel: 'amp',
+      type: 'embed-size',
+      width: width,
+      height: height
+    }, '*');
+  }
+}
+
+/**
+ * Returns cache endpoint concatenated with cache path
+ * @param {string} cacheHost Cache Endpoint host
+ * @param {string} cachePath Cache Endpoint path
+ */
+function getCacheEndpoint(cacheHost, cachePath) {
+  var host = typeof cacheHost === 'undefined' || cacheHost === "" ? DEFAULT_CACHE_HOST : cacheHost;
+  var path = typeof cachePath === 'undefined' || cachePath === "" ? DEFAULT_CACHE_PATH : cachePath;
+  return "https://".concat(host).concat(path);
+}
+
+/**
+ * Cache request Callback to display creative
+ * @param {Bool} isMobileApp
+ * @param {string} hbPb final price of the winning bid
+ * @returns {function} a callback function that parses response
+ */
+function responseCallback(isMobileApp, hbPb) {
+  return function (response) {
+    var bidObject = parseResponse(response);
+    var auctionPrice = bidObject.price || hbPb;
+    var ad = (0, _utils.getCreativeCommentMarkup)(bidObject);
+    var width = bidObject.width ? bidObject.width : bidObject.w;
+    var height = bidObject.height ? bidObject.height : bidObject.h;
+
+    // When Prebid Universal Creative reads from Prebid Cache, we need to have it check for the existence of the wurl parameter. If it exists, hit it.
+    if (bidObject.wurl) {
+      (0, _utils.triggerPixel)(decodeURIComponent(bidObject.wurl));
+    }
+    if (bidObject.adm) {
+      if (auctionPrice) {
+        // replace ${AUCTION_PRICE} macro with the bidObject.price or hb_pb.
+        bidObject.adm = bidObject.adm.replace('${AUCTION_PRICE}', auctionPrice);
+      } else {
+        /*
+          From OpenRTB spec 2.5: If the source value is an optional parameter that was not specified, the macro will simply be removed (i.e., replaced with a zero-length string).
+         */
+        bidObject.adm = bidObject.adm.replace('${AUCTION_PRICE}', '');
+      }
+      ad += isMobileApp ? constructMarkup(bidObject.adm, width, height) : bidObject.adm;
+      if (bidObject.nurl) {
+        ad += (0, _utils.createTrackPixelHtml)(decodeURIComponent(bidObject.nurl));
+      }
+      if (bidObject.burl) {
+        var triggerBurl = function triggerBurl() {
+          (0, _utils.triggerPixel)(bidObject.burl);
+        };
+        if (isMobileApp) {
+          (0, _utils.loadScript)(window, 'mraid.js', function () {
+            // Success loading MRAID
+            var result = registerMRAIDViewableEvent(triggerBurl);
+            if (!result) {
+              triggerBurl(); // Error registering event
+            }
+          }, triggerBurl // Error loading MRAID
+          );
+        } else {
+          triggerBurl(); // Not a mobile app
+        }
+      }
+      (0, _postscribeRender.writeAdHtml)(ad);
+    } else if (bidObject.nurl) {
+      if (isMobileApp) {
+        var adhtml = (0, _utils.loadScript)(window, bidObject.nurl);
+        ad += constructMarkup(adhtml.outerHTML, width, height);
+        (0, _postscribeRender.writeAdHtml)(ad);
+      } else {
+        var nurl = bidObject.nurl;
+        var commentElm = (0, _utils.getCreativeComment)(bidObject);
+        (0, _domHelper.insertElement)(commentElm, document, 'body');
+        (0, _utils.writeAdUrl)(nurl, width, height);
+      }
+    }
+  };
+}
+;
+
+/**
+ * Parse response
+ * @param {string} response
+ * @returns {Object} bidObject parsed response
+ */
+function parseResponse(response) {
+  var bidObject;
+  try {
+    bidObject = JSON.parse(response);
+  } catch (error) {
+    console.log("Error parsing response from cache host: ".concat(error));
+  }
+  return bidObject;
+}
+
+/**
+ * Wrap mobile app creative in div
+ * @param {string} ad html for creative
+ * @param {Number} width width of creative
+ * @param {Number} height height of creative
+ * @returns {string} creative markup
+ */
+function constructMarkup(ad, width, height) {
+  var id = (0, _utils.getUUID)();
+  return "<div id=\"".concat(id, "\" style=\"border-style: none; position: absolute; width:100%; height:100%;\">\n      <div id=\"").concat(id, "_inner\" style=\"margin: 0 auto; width:").concat(width, "px; height:").concat(height, "px; position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%);\">").concat(ad, "</div>\n      </div>");
+}
+function registerMRAIDViewableEvent(callback) {
+  function exposureChangeListener(exposure) {
+    if (exposure > 0) {
+      mraid.removeEventListener('exposureChange', exposureChangeListener);
+      callback();
+    }
+  }
+  function viewableChangeListener(viewable) {
+    if (viewable) {
+      mraid.removeEventListener('viewableChange', viewableChangeListener);
+      callback();
+    }
+  }
+  function registerViewableChecks() {
+    if (window.MRAID_ENV && parseFloat(window.MRAID_ENV.version) >= 3) {
+      mraid.addEventListener('exposureChange', exposureChangeListener);
+    } else if (window.MRAID_ENV && parseFloat(window.MRAID_ENV.version) < 3) {
+      if (mraid.isViewable()) {
+        callback();
+      } else {
+        mraid.addEventListener('viewableChange', viewableChangeListener);
+      }
+    }
+  }
+  function readyListener() {
+    mraid.removeEventListener('ready', readyListener);
+    registerViewableChecks();
+  }
+  if (window.mraid && window.MRAID_ENV) {
+    if (mraid.getState() == 'loading') {
+      mraid.addEventListener('ready', readyListener);
+    } else {
+      registerViewableChecks();
+    }
+    return true;
+  } else {
+    return false;
+  }
+}
+
+/***/ }),
+/* 8 */
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.writeAdHtml = writeAdHtml;
+var _postscribe = _interopRequireDefault(__webpack_require__(9));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; }
+function writeAdHtml(markup) {
+  var ps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _postscribe["default"];
+  // remove <?xml> and <!doctype> tags
+  // https://github.com/prebid/prebid-universal-creative/issues/134
+  markup = markup.replace(/<\?xml\b[^>]*(?:\?>|>)/gi, '').replace(/<!doctype\b[^>\[]*(?:\[[^\]]*\][^>]*)?>/gi, '');
+  var finalMarkup;
+  try {
+    finalMarkup = normalizeMarkup(markup);
+  } catch (error) {
+    console.error("Error normalizing markup:", error.message);
+    finalMarkup = markup;
+  }
+  ps(document.body, finalMarkup, {
+    error: console.error
+  });
+}
+
+/**
+ * Normalizes an HTML string by parsing and re-serializing it,
+ * returning the content between custom PUC_START and PUC_END markers.
+ *
+ * This function is specifically aimed at addressing an issue with `postscribe` where double quotes inside single-quoted
+ * HTML attributes are not correctly escaped.
+ */
+function normalizeMarkup(markup) {
+  var timestamp = Date.now();
+  var startMarkerId = "PUC_START_".concat(timestamp);
+  var endMarkerId = "PUC_END_".concat(timestamp);
+  var startMarker = "<div id=\"".concat(startMarkerId, "\"></div>");
+  var endMarker = "<div id=\"".concat(endMarkerId, "\"></div>");
+  var doc = new DOMParser().parseFromString("".concat(startMarker).concat(markup).concat(endMarker), "text/html");
+  var textMap = new Map();
+  var textId = 0;
+  var replaceTextNodes = function replaceTextNodes(node) {
+    if (node.nodeType === Node.TEXT_NODE && node.textContent.trim()) {
+      var id = "PUC_NODE_TEXT_".concat(textId++, "_").concat(timestamp);
+      textMap.set(id, node.textContent);
+      var span = doc.createElement("span");
+      span.dataset.textId = id;
+      node.parentNode.replaceChild(span, node);
+    } else {
+      _toConsumableArray(node.childNodes).forEach(replaceTextNodes);
+    }
+  };
+  var current = doc.querySelector("#".concat(startMarkerId)).nextSibling;
+  var end = doc.querySelector("#".concat(endMarkerId));
+  while (current && current !== end) {
+    replaceTextNodes(current);
+    current = current.nextSibling;
+  }
+  var serialized = new XMLSerializer().serializeToString(doc);
+  var snippet = serialized.split(startMarker)[1].split(endMarker)[0].replace(/<span data-text-id="(PUC_NODE_TEXT_\d+_\d+)"[^>]*><\/span>/g, function (_, id) {
+    return textMap.get(id) || "";
+  });
+  return snippet.trim();
+}
+
+/***/ }),
+/* 9 */
+/***/ (function(module) {
+
+/**
+ * @file postscribe
+ * @description Asynchronously write javascript, even with document.write.
+ * @version v2.0.8
+ * @see {@link https://krux.github.io/postscribe}
+ * @license MIT
+ * @author Derek Brans
+ * @copyright 2016 Krux Digital, Inc
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(true)
+		module.exports = factory();
+	else // removed by dead control flow
+{}
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __nested_webpack_require_791__(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] = {
+/******/ 			exports: {},
+/******/ 			id: moduleId,
+/******/ 			loaded: false
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_791__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.loaded = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__nested_webpack_require_791__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__nested_webpack_require_791__.c = installedModules;
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__nested_webpack_require_791__.p = "";
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __nested_webpack_require_791__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __nested_webpack_require_2071__) {
+
+	'use strict';
+	
+	var _postscribe = __nested_webpack_require_2071__(1);
+	
+	var _postscribe2 = _interopRequireDefault(_postscribe);
+	
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+	
+	module.exports = _postscribe2['default'];
+
+/***/ },
+/* 1 */
+/***/ function(module, exports, __nested_webpack_require_2410__) {
+
+	'use strict';
+	
+	exports.__esModule = true;
+	
+	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+	
+	exports['default'] = postscribe;
+	
+	var _writeStream = __nested_webpack_require_2410__(2);
+	
+	var _writeStream2 = _interopRequireDefault(_writeStream);
+	
+	var _utils = __nested_webpack_require_2410__(4);
+	
+	var utils = _interopRequireWildcard(_utils);
+	
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+	
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+	
+	/**
+	 * A function that intentionally does nothing.
+	 */
+	function doNothing() {}
+	
+	/**
+	 * Available options and defaults.
+	 *
+	 * @type {Object}
+	 */
+	var OPTIONS = {
+	  /**
+	   * Called when an async script has loaded.
+	   */
+	  afterAsync: doNothing,
+	
+	  /**
+	   * Called immediately before removing from the write queue.
+	   */
+	  afterDequeue: doNothing,
+	
+	  /**
+	   * Called sync after a stream's first thread release.
+	   */
+	  afterStreamStart: doNothing,
+	
+	  /**
+	   * Called after writing buffered document.write calls.
+	   */
+	  afterWrite: doNothing,
+	
+	  /**
+	   * Allows disabling the autoFix feature of prescribe
+	   */
+	  autoFix: true,
+	
+	  /**
+	   * Called immediately before adding to the write queue.
+	   */
+	  beforeEnqueue: doNothing,
+	
+	  /**
+	   * Called before writing a token.
+	   *
+	   * @param {Object} tok The token
+	   */
+	  beforeWriteToken: function beforeWriteToken(tok) {
+	    return tok;
+	  },
+	
+	  /**
+	   * Called before writing buffered document.write calls.
+	   *
+	   * @param {String} str The string
+	   */
+	  beforeWrite: function beforeWrite(str) {
+	    return str;
+	  },
+	
+	  /**
+	   * Called when evaluation is finished.
+	   */
+	  done: doNothing,
+	
+	  /**
+	   * Called when a write results in an error.
+	   *
+	   * @param {Error} e The error
+	   */
+	  error: function error(e) {
+	    throw new Error(e.msg);
+	  },
+	
+	
+	  /**
+	   * Whether to let scripts w/ async attribute set fall out of the queue.
+	   */
+	  releaseAsync: false
+	};
+	
+	var nextId = 0;
+	var queue = [];
+	var active = null;
+	
+	function nextStream() {
+	  var args = queue.shift();
+	  if (args) {
+	    var options = utils.last(args);
+	
+	    options.afterDequeue();
+	    args.stream = runStream.apply(undefined, args);
+	    options.afterStreamStart();
+	  }
+	}
+	
+	function runStream(el, html, options) {
+	  active = new _writeStream2['default'](el, options);
+	
+	  // Identify this stream.
+	  active.id = nextId++;
+	  active.name = options.name || active.id;
+	  postscribe.streams[active.name] = active;
+	
+	  // Override document.write.
+	  var doc = el.ownerDocument;
+	
+	  var stash = {
+	    close: doc.close,
+	    open: doc.open,
+	    write: doc.write,
+	    writeln: doc.writeln
+	  };
+	
+	  function _write(str) {
+	    str = options.beforeWrite(str);
+	    active.write(str);
+	    options.afterWrite(str);
+	  }
+	
+	  _extends(doc, {
+	    close: doNothing,
+	    open: doNothing,
+	    write: function write() {
+	      for (var _len = arguments.length, str = Array(_len), _key = 0; _key < _len; _key++) {
+	        str[_key] = arguments[_key];
+	      }
+	
+	      return _write(str.join(''));
+	    },
+	    writeln: function writeln() {
+	      for (var _len2 = arguments.length, str = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+	        str[_key2] = arguments[_key2];
+	      }
+	
+	      return _write(str.join('') + '\n');
+	    }
+	  });
+	
+	  // Override window.onerror
+	  var oldOnError = active.win.onerror || doNothing;
+	
+	  // This works together with the try/catch around WriteStream::insertScript
+	  // In modern browsers, exceptions in tag scripts go directly to top level
+	  active.win.onerror = function (msg, url, line) {
+	    options.error({ msg: msg + ' - ' + url + ': ' + line });
+	    oldOnError.apply(active.win, [msg, url, line]);
+	  };
+	
+	  // Write to the stream
+	  active.write(html, function () {
+	    // restore document.write
+	    _extends(doc, stash);
+	
+	    // restore window.onerror
+	    active.win.onerror = oldOnError;
+	
+	    options.done();
+	    active = null;
+	    nextStream();
+	  });
+	
+	  return active;
+	}
+	
+	function postscribe(el, html, options) {
+	  if (utils.isFunction(options)) {
+	    options = { done: options };
+	  } else if (options === 'clear') {
+	    queue = [];
+	    active = null;
+	    nextId = 0;
+	    return;
+	  }
+	
+	  options = utils.defaults(options, OPTIONS);
+	
+	  // id selector
+	  if (/^#/.test(el)) {
+	    el = window.document.getElementById(el.substr(1));
+	  } else {
+	    el = el.jquery ? el[0] : el;
+	  }
+	
+	  var args = [el, html, options];
+	
+	  el.postscribe = {
+	    cancel: function cancel() {
+	      if (args.stream) {
+	        args.stream.abort();
+	      } else {
+	        args[1] = doNothing;
+	      }
+	    }
+	  };
+	
+	  options.beforeEnqueue(args);
+	  queue.push(args);
+	
+	  if (!active) {
+	    nextStream();
+	  }
+	
+	  return el.postscribe;
+	}
+	
+	_extends(postscribe, {
+	  // Streams by name.
+	  streams: {},
+	  // Queue of streams.
+	  queue: queue,
+	  // Expose internal classes.
+	  WriteStream: _writeStream2['default']
+	});
+
+/***/ },
+/* 2 */
+/***/ function(module, exports, __nested_webpack_require_7899__) {
+
+	'use strict';
+	
+	exports.__esModule = true;
+	
+	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+	
+	var _prescribe = __nested_webpack_require_7899__(3);
+	
+	var _prescribe2 = _interopRequireDefault(_prescribe);
+	
+	var _utils = __nested_webpack_require_7899__(4);
+	
+	var utils = _interopRequireWildcard(_utils);
+	
+	function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+	
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+	
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	
+	/**
+	 * Turn on to debug how each chunk affected the DOM.
+	 * @type {boolean}
+	 */
+	var DEBUG_CHUNK = false;
+	
+	/**
+	 * Prefix for data attributes on DOM elements.
+	 * @type {string}
+	 */
+	var BASEATTR = 'data-ps-';
+	
+	/**
+	 * ID for the style proxy
+	 * @type {string}
+	 */
+	var PROXY_STYLE = 'ps-style';
+	
+	/**
+	 * ID for the script proxy
+	 * @type {string}
+	 */
+	var PROXY_SCRIPT = 'ps-script';
+	
+	/**
+	 * Get data attributes
+	 *
+	 * @param {Object} el The DOM element.
+	 * @param {String} name The attribute name.
+	 * @returns {String}
+	 */
+	function getData(el, name) {
+	  var attr = BASEATTR + name;
+	
+	  var val = el.getAttribute(attr);
+	
+	  // IE 8 returns a number if it's a number
+	  return !utils.existy(val) ? val : String(val);
+	}
+	
+	/**
+	 * Set data attributes
+	 *
+	 * @param {Object} el The DOM element.
+	 * @param {String} name The attribute name.
+	 * @param {null|*} value The attribute value.
+	 */
+	function setData(el, name) {
+	  var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+	
+	  var attr = BASEATTR + name;
+	
+	  if (utils.existy(value) && value !== '') {
+	    el.setAttribute(attr, value);
+	  } else {
+	    el.removeAttribute(attr);
+	  }
+	}
+	
+	/**
+	 * Stream static html to an element, where "static html" denotes "html
+	 * without scripts".
+	 *
+	 * This class maintains a *history of writes devoid of any attributes* or
+	 * "proxy history".
+	 *
+	 * Injecting the proxy history into a temporary div has no side-effects,
+	 * other than to create proxy elements for previously written elements.
+	 *
+	 * Given the `staticHtml` of a new write, a `tempDiv`'s innerHTML is set to
+	 * `proxy_history + staticHtml`.
+	 * The *structure* of `tempDiv`'s contents, (i.e., the placement of new nodes
+	 * beside or inside of proxy elements), reflects the DOM structure that would
+	 * have resulted if all writes had been squashed into a single write.
+	 *
+	 * For each descendent `node` of `tempDiv` whose parentNode is a *proxy*,
+	 * `node` is appended to the corresponding *real* element within the DOM.
+	 *
+	 * Proxy elements are mapped to *actual* elements in the DOM by injecting a
+	 * `data-id` attribute into each start tag in `staticHtml`.
+	 *
+	 */
+	
+	var WriteStream = function () {
+	  /**
+	   * Constructor.
+	   *
+	   * @param {Object} root The root element
+	   * @param {?Object} options The options
+	   */
+	  function WriteStream(root) {
+	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	
+	    _classCallCheck(this, WriteStream);
+	
+	    this.root = root;
+	    this.options = options;
+	    this.doc = root.ownerDocument;
+	    this.win = this.doc.defaultView || this.doc.parentWindow;
+	    this.parser = new _prescribe2['default']('', { autoFix: options.autoFix });
+	
+	    // Actual elements by id.
+	    this.actuals = [root];
+	
+	    // Embodies the "structure" of what's been written so far,
+	    // devoid of attributes.
+	    this.proxyHistory = '';
+	
+	    // Create a proxy of the root element.
+	    this.proxyRoot = this.doc.createElement(root.nodeName);
+	
+	    this.scriptStack = [];
+	    this.writeQueue = [];
+	
+	    setData(this.proxyRoot, 'proxyof', 0);
+	  }
+	
+	  /**
+	   * Writes the given strings.
+	   *
+	   * @param {...String} str The strings to write
+	   */
+	
+	
+	  WriteStream.prototype.write = function write() {
+	    var _writeQueue;
+	
+	    (_writeQueue = this.writeQueue).push.apply(_writeQueue, arguments);
+	
+	    // Process writes
+	    // When new script gets pushed or pending this will stop
+	    // because new writeQueue gets pushed
+	    while (!this.deferredRemote && this.writeQueue.length) {
+	      var arg = this.writeQueue.shift();
+	
+	      if (utils.isFunction(arg)) {
+	        this._callFunction(arg);
+	      } else {
+	        this._writeImpl(arg);
+	      }
+	    }
+	  };
+	
+	  /**
+	   * Calls the given function.
+	   *
+	   * @param {Function} fn The function to call
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._callFunction = function _callFunction(fn) {
+	    var tok = { type: 'function', value: fn.name || fn.toString() };
+	    this._onScriptStart(tok);
+	    fn.call(this.win, this.doc);
+	    this._onScriptDone(tok);
+	  };
+	
+	  /**
+	   * The write implementation
+	   *
+	   * @param {String} html The HTML to write.
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._writeImpl = function _writeImpl(html) {
+	    this.parser.append(html);
+	
+	    var tok = void 0;
+	    var script = void 0;
+	    var style = void 0;
+	    var tokens = [];
+	
+	    // stop if we see a script token
+	    while ((tok = this.parser.readToken()) && !(script = utils.isScript(tok)) && !(style = utils.isStyle(tok))) {
+	      tok = this.options.beforeWriteToken(tok);
+	
+	      if (tok) {
+	        tokens.push(tok);
+	      }
+	    }
+	
+	    if (tokens.length > 0) {
+	      this._writeStaticTokens(tokens);
+	    }
+	
+	    if (script) {
+	      this._handleScriptToken(tok);
+	    }
+	
+	    if (style) {
+	      this._handleStyleToken(tok);
+	    }
+	  };
+	
+	  /**
+	   * Write contiguous non-script tokens (a chunk)
+	   *
+	   * @param {Array<Object>} tokens The tokens
+	   * @returns {{tokens, raw, actual, proxy}|null}
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._writeStaticTokens = function _writeStaticTokens(tokens) {
+	    var chunk = this._buildChunk(tokens);
+	
+	    if (!chunk.actual) {
+	      // e.g., no tokens, or a noscript that got ignored
+	      return null;
+	    }
+	
+	    chunk.html = this.proxyHistory + chunk.actual;
+	    this.proxyHistory += chunk.proxy;
+	    this.proxyRoot.innerHTML = chunk.html;
+	
+	    if (DEBUG_CHUNK) {
+	      chunk.proxyInnerHTML = this.proxyRoot.innerHTML;
+	    }
+	
+	    this._walkChunk();
+	
+	    if (DEBUG_CHUNK) {
+	      chunk.actualInnerHTML = this.root.innerHTML;
+	    }
+	
+	    return chunk;
+	  };
+	
+	  /**
+	   * Build a chunk.
+	   *
+	   * @param {Array<Object>} tokens The tokens to use.
+	   * @returns {{tokens: *, raw: string, actual: string, proxy: string}}
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._buildChunk = function _buildChunk(tokens) {
+	    var nextId = this.actuals.length;
+	
+	    // The raw html of this chunk.
+	    var raw = [];
+	
+	    // The html to create the nodes in the tokens (with id's injected).
+	    var actual = [];
+	
+	    // Html that can later be used to proxy the nodes in the tokens.
+	    var proxy = [];
+	
+	    var len = tokens.length;
+	    for (var i = 0; i < len; i++) {
+	      var tok = tokens[i];
+	      var tokenRaw = tok.toString();
+	
+	      raw.push(tokenRaw);
+	
+	      if (tok.attrs) {
+	        // tok.attrs <==> startTag or atomicTag or cursor
+	        // Ignore noscript tags. They are atomic, so we don't have to worry about children.
+	        if (!/^noscript$/i.test(tok.tagName)) {
+	          var id = nextId++;
+	
+	          // Actual: inject id attribute: replace '>' at end of start tag with id attribute + '>'
+	          actual.push(tokenRaw.replace(/(\/?>)/, ' ' + BASEATTR + 'id=' + id + ' $1'));
+	
+	          // Don't proxy scripts: they have no bearing on DOM structure.
+	          if (tok.attrs.id !== PROXY_SCRIPT && tok.attrs.id !== PROXY_STYLE) {
+	            // Proxy: strip all attributes and inject proxyof attribute
+	            proxy.push(
+	            // ignore atomic tags (e.g., style): they have no "structural" effect
+	            tok.type === 'atomicTag' ? '' : '<' + tok.tagName + ' ' + BASEATTR + 'proxyof=' + id + (tok.unary ? ' />' : '>'));
+	          }
+	        }
+	      } else {
+	        // Visit any other type of token
+	        // Actual: append.
+	        actual.push(tokenRaw);
+	
+	        // Proxy: append endTags. Ignore everything else.
+	        proxy.push(tok.type === 'endTag' ? tokenRaw : '');
+	      }
+	    }
+	
+	    return {
+	      tokens: tokens,
+	      raw: raw.join(''),
+	      actual: actual.join(''),
+	      proxy: proxy.join('')
+	    };
+	  };
+	
+	  /**
+	   * Walk the chunks.
+	   *
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._walkChunk = function _walkChunk() {
+	    var node = void 0;
+	    var stack = [this.proxyRoot];
+	
+	    // use shift/unshift so that children are walked in document order
+	    while (utils.existy(node = stack.shift())) {
+	      var isElement = node.nodeType === 1;
+	      var isProxy = isElement && getData(node, 'proxyof');
+	
+	      // Ignore proxies
+	      if (!isProxy) {
+	        if (isElement) {
+	          // New actual element: register it and remove the the id attr.
+	          this.actuals[getData(node, 'id')] = node;
+	          setData(node, 'id');
+	        }
+	
+	        // Is node's parent a proxy?
+	        var parentIsProxyOf = node.parentNode && getData(node.parentNode, 'proxyof');
+	        if (parentIsProxyOf) {
+	          // Move node under actual parent.
+	          this.actuals[parentIsProxyOf].appendChild(node);
+	        }
+	      }
+	
+	      // prepend childNodes to stack
+	      stack.unshift.apply(stack, utils.toArray(node.childNodes));
+	    }
+	  };
+	
+	  /**
+	   * Handles Script tokens
+	   *
+	   * @param {Object} tok The token
+	   */
+	
+	
+	  WriteStream.prototype._handleScriptToken = function _handleScriptToken(tok) {
+	    var _this = this;
+	
+	    var remainder = this.parser.clear();
+	
+	    if (remainder) {
+	      // Write remainder immediately behind this script.
+	      this.writeQueue.unshift(remainder);
+	    }
+	
+	    tok.src = tok.attrs.src || tok.attrs.SRC;
+	
+	    tok = this.options.beforeWriteToken(tok);
+	    if (!tok) {
+	      // User has removed this token
+	      return;
+	    }
+	
+	    if (tok.src && this.scriptStack.length) {
+	      // Defer this script until scriptStack is empty.
+	      // Assumption 1: This script will not start executing until
+	      // scriptStack is empty.
+	      this.deferredRemote = tok;
+	    } else {
+	      this._onScriptStart(tok);
+	    }
+	
+	    // Put the script node in the DOM.
+	    this._writeScriptToken(tok, function () {
+	      _this._onScriptDone(tok);
+	    });
+	  };
+	
+	  /**
+	   * Handles style tokens
+	   *
+	   * @param {Object} tok The token
+	   */
+	
+	
+	  WriteStream.prototype._handleStyleToken = function _handleStyleToken(tok) {
+	    var remainder = this.parser.clear();
+	
+	    if (remainder) {
+	      // Write remainder immediately behind this style.
+	      this.writeQueue.unshift(remainder);
+	    }
+	
+	    tok.type = tok.attrs.type || tok.attrs.TYPE || 'text/css';
+	
+	    tok = this.options.beforeWriteToken(tok);
+	
+	    if (tok) {
+	      // Put the style node in the DOM.
+	      this._writeStyleToken(tok);
+	    }
+	
+	    if (remainder) {
+	      this.write();
+	    }
+	  };
+	
+	  /**
+	   * Build a style and insert it into the DOM.
+	   *
+	   * @param {Object} tok The token
+	   */
+	
+	
+	  WriteStream.prototype._writeStyleToken = function _writeStyleToken(tok) {
+	    var el = this._buildStyle(tok);
+	
+	    this._insertCursor(el, PROXY_STYLE);
+	
+	    // Set content
+	    if (tok.content) {
+	      if (el.styleSheet && !el.sheet) {
+	        el.styleSheet.cssText = tok.content;
+	      } else {
+	        el.appendChild(this.doc.createTextNode(tok.content));
+	      }
+	    }
+	  };
+	
+	  /**
+	   * Build a style element from an atomic style token.
+	   *
+	   * @param {Object} tok The token
+	   * @returns {Element}
+	   */
+	
+	
+	  WriteStream.prototype._buildStyle = function _buildStyle(tok) {
+	    var el = this.doc.createElement(tok.tagName);
+	
+	    el.setAttribute('type', tok.type);
+	
+	    // Set attributes
+	    utils.eachKey(tok.attrs, function (name, value) {
+	      el.setAttribute(name, value);
+	    });
+	
+	    return el;
+	  };
+	
+	  /**
+	   * Append a span to the stream. That span will act as a cursor
+	   * (i.e. insertion point) for the element.
+	   *
+	   * @param {Object} el The element
+	   * @param {string} which The type of proxy element
+	   */
+	
+	
+	  WriteStream.prototype._insertCursor = function _insertCursor(el, which) {
+	    this._writeImpl('<span id="' + which + '"/>');
+	
+	    var cursor = this.doc.getElementById(which);
+	
+	    if (cursor) {
+	      cursor.parentNode.replaceChild(el, cursor);
+	    }
+	  };
+	
+	  /**
+	   * Called when a script is started.
+	   *
+	   * @param {Object} tok The token
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._onScriptStart = function _onScriptStart(tok) {
+	    tok.outerWrites = this.writeQueue;
+	    this.writeQueue = [];
+	    this.scriptStack.unshift(tok);
+	  };
+	
+	  /**
+	   * Called when a script is done.
+	   *
+	   * @param {Object} tok The token
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._onScriptDone = function _onScriptDone(tok) {
+	    // Pop script and check nesting.
+	    if (tok !== this.scriptStack[0]) {
+	      this.options.error({ msg: 'Bad script nesting or script finished twice' });
+	      return;
+	    }
+	
+	    this.scriptStack.shift();
+	
+	    // Append outer writes to queue and process them.
+	    this.write.apply(this, tok.outerWrites);
+	
+	    // Check for pending remote
+	
+	    // Assumption 2: if remote_script1 writes remote_script2 then
+	    // the we notice remote_script1 finishes before remote_script2 starts.
+	    // I think this is equivalent to assumption 1
+	    if (!this.scriptStack.length && this.deferredRemote) {
+	      this._onScriptStart(this.deferredRemote);
+	      this.deferredRemote = null;
+	    }
+	  };
+	
+	  /**
+	   * Build a script and insert it into the DOM.
+	   * Done is called once script has executed.
+	   *
+	   * @param {Object} tok The token
+	   * @param {Function} done The callback when complete
+	   */
+	
+	
+	  WriteStream.prototype._writeScriptToken = function _writeScriptToken(tok, done) {
+	    var el = this._buildScript(tok);
+	    var asyncRelease = this._shouldRelease(el);
+	    var afterAsync = this.options.afterAsync;
+	
+	    if (tok.src) {
+	      // Fix for attribute "SRC" (capitalized). IE does not recognize it.
+	      el.src = tok.src;
+	      this._scriptLoadHandler(el, !asyncRelease ? function () {
+	        done();
+	        afterAsync();
+	      } : afterAsync);
+	    }
+	
+	    try {
+	      this._insertCursor(el, PROXY_SCRIPT);
+	      if (!el.src || asyncRelease) {
+	        done();
+	      }
+	    } catch (e) {
+	      this.options.error(e);
+	      done();
+	    }
+	  };
+	
+	  /**
+	   * Build a script element from an atomic script token.
+	   *
+	   * @param {Object} tok The token
+	   * @returns {Element}
+	   */
+	
+	
+	  WriteStream.prototype._buildScript = function _buildScript(tok) {
+	    var el = this.doc.createElement(tok.tagName);
+	
+	    // Set attributes
+	    utils.eachKey(tok.attrs, function (name, value) {
+	      el.setAttribute(name, value);
+	    });
+	
+	    // Set content
+	    if (tok.content) {
+	      el.text = tok.content;
+	    }
+	
+	    return el;
+	  };
+	
+	  /**
+	   * Setup the script load handler on an element.
+	   *
+	   * @param {Object} el The element
+	   * @param {Function} done The callback
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._scriptLoadHandler = function _scriptLoadHandler(el, done) {
+	    function cleanup() {
+	      el = el.onload = el.onreadystatechange = el.onerror = null;
+	    }
+	
+	    var error = this.options.error;
+	
+	    function success() {
+	      cleanup();
+	      if (done != null) {
+	        done();
+	      }
+	      done = null;
+	    }
+	
+	    function failure(err) {
+	      cleanup();
+	      error(err);
+	      if (done != null) {
+	        done();
+	      }
+	      done = null;
+	    }
+	
+	    function reattachEventListener(el, evt) {
+	      var handler = el['on' + evt];
+	      if (handler != null) {
+	        el['_on' + evt] = handler;
+	      }
+	    }
+	
+	    reattachEventListener(el, 'load');
+	    reattachEventListener(el, 'error');
+	
+	    _extends(el, {
+	      onload: function onload() {
+	        if (el._onload) {
+	          try {
+	            el._onload.apply(this, Array.prototype.slice.call(arguments, 0));
+	          } catch (err) {
+	            failure({ msg: 'onload handler failed ' + err + ' @ ' + el.src });
+	          }
+	        }
+	        success();
+	      },
+	      onerror: function onerror() {
+	        if (el._onerror) {
+	          try {
+	            el._onerror.apply(this, Array.prototype.slice.call(arguments, 0));
+	          } catch (err) {
+	            failure({ msg: 'onerror handler failed ' + err + ' @ ' + el.src });
+	            return;
+	          }
+	        }
+	        failure({ msg: 'remote script failed ' + el.src });
+	      },
+	      onreadystatechange: function onreadystatechange() {
+	        if (/^(loaded|complete)$/.test(el.readyState)) {
+	          success();
+	        }
+	      }
+	    });
+	  };
+	
+	  /**
+	   * Determines whether to release.
+	   *
+	   * @param {Object} el The element
+	   * @returns {boolean}
+	   * @private
+	   */
+	
+	
+	  WriteStream.prototype._shouldRelease = function _shouldRelease(el) {
+	    var isScript = /^script$/i.test(el.nodeName);
+	    return !isScript || !!(this.options.releaseAsync && el.src && el.hasAttribute('async'));
+	  };
+	
+	  return WriteStream;
+	}();
+	
+	exports['default'] = WriteStream;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/**
+	 * @file prescribe
+	 * @description Tiny, forgiving HTML parser
+	 * @version vundefined
+	 * @see {@link https://github.com/krux/prescribe/}
+	 * @license MIT
+	 * @author Derek Brans
+	 * @copyright 2016 Krux Digital, Inc
+	 */
+	(function webpackUniversalModuleDefinition(root, factory) {
+		if(true)
+			module.exports = factory();
+		else // removed by dead control flow
+{}
+	})(this, function() {
+	return /******/ (function(modules) { // webpackBootstrap
+	/******/ 	// The module cache
+	/******/ 	var installedModules = {};
+	
+	/******/ 	// The require function
+	/******/ 	function __nested_webpack_require_26473__(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] = {
+	/******/ 			exports: {},
+	/******/ 			id: moduleId,
+	/******/ 			loaded: false
+	/******/ 		};
+	
+	/******/ 		// Execute the module function
+	/******/ 		modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_26473__);
+	
+	/******/ 		// Flag the module as loaded
+	/******/ 		module.loaded = true;
+	
+	/******/ 		// Return the exports of the module
+	/******/ 		return module.exports;
+	/******/ 	}
+	
+	
+	/******/ 	// expose the modules object (__webpack_modules__)
+	/******/ 	__nested_webpack_require_26473__.m = modules;
+	
+	/******/ 	// expose the module cache
+	/******/ 	__nested_webpack_require_26473__.c = installedModules;
+	
+	/******/ 	// __webpack_public_path__
+	/******/ 	__nested_webpack_require_26473__.p = "";
+	
+	/******/ 	// Load entry module and return exports
+	/******/ 	return __nested_webpack_require_26473__(0);
+	/******/ })
+	/************************************************************************/
+	/******/ ([
+	/* 0 */
+	/***/ function(module, exports, __nested_webpack_require_27712__) {
+	
+		'use strict';
+	
+		var _HtmlParser = __nested_webpack_require_27712__(1);
+	
+		var _HtmlParser2 = _interopRequireDefault(_HtmlParser);
+	
+		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+	
+		module.exports = _HtmlParser2['default'];
+	
+	/***/ },
+	/* 1 */
+	/***/ function(module, exports, __nested_webpack_require_28061__) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+	
+		var _supports = __nested_webpack_require_28061__(2);
+	
+		var supports = _interopRequireWildcard(_supports);
+	
+		var _streamReaders = __nested_webpack_require_28061__(3);
+	
+		var streamReaders = _interopRequireWildcard(_streamReaders);
+	
+		var _fixedReadTokenFactory = __nested_webpack_require_28061__(6);
+	
+		var _fixedReadTokenFactory2 = _interopRequireDefault(_fixedReadTokenFactory);
+	
+		var _utils = __nested_webpack_require_28061__(5);
+	
+		function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+	
+		function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } }
+	
+		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	
+		/**
+		 * Detection regular expressions.
+		 *
+		 * Order of detection matters: detection of one can only
+		 * succeed if detection of previous didn't
+	
+		 * @type {Object}
+		 */
+		var detect = {
+		  comment: /^<!--/,
+		  endTag: /^<\//,
+		  atomicTag: /^<\s*(script|style|noscript|iframe|textarea)[\s\/>]/i,
+		  startTag: /^</,
+		  chars: /^[^<]/
+		};
+	
+		/**
+		 * HtmlParser provides the capability to parse HTML and return tokens
+		 * representing the tags and content.
+		 */
+	
+		var HtmlParser = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} stream The initial parse stream contents.
+		   * @param {Object} options The options
+		   * @param {boolean} options.autoFix Set to true to automatically fix errors
+		   */
+		  function HtmlParser() {
+		    var _this = this;
+	
+		    var stream = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+		    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	
+		    _classCallCheck(this, HtmlParser);
+	
+		    this.stream = stream;
+	
+		    var fix = false;
+		    var fixedTokenOptions = {};
+	
+		    for (var key in supports) {
+		      if (supports.hasOwnProperty(key)) {
+		        if (options.autoFix) {
+		          fixedTokenOptions[key + 'Fix'] = true; // !supports[key];
+		        }
+		        fix = fix || fixedTokenOptions[key + 'Fix'];
+		      }
+		    }
+	
+		    if (fix) {
+		      this._readToken = (0, _fixedReadTokenFactory2['default'])(this, fixedTokenOptions, function () {
+		        return _this._readTokenImpl();
+		      });
+		      this._peekToken = (0, _fixedReadTokenFactory2['default'])(this, fixedTokenOptions, function () {
+		        return _this._peekTokenImpl();
+		      });
+		    } else {
+		      this._readToken = this._readTokenImpl;
+		      this._peekToken = this._peekTokenImpl;
+		    }
+		  }
+	
+		  /**
+		   * Appends the given string to the parse stream.
+		   *
+		   * @param {string} str The string to append
+		   */
+	
+	
+		  HtmlParser.prototype.append = function append(str) {
+		    this.stream += str;
+		  };
+	
+		  /**
+		   * Prepends the given string to the parse stream.
+		   *
+		   * @param {string} str The string to prepend
+		   */
+	
+	
+		  HtmlParser.prototype.prepend = function prepend(str) {
+		    this.stream = str + this.stream;
+		  };
+	
+		  /**
+		   * The implementation of the token reading.
+		   *
+		   * @private
+		   * @returns {?Token}
+		   */
+	
+	
+		  HtmlParser.prototype._readTokenImpl = function _readTokenImpl() {
+		    var token = this._peekTokenImpl();
+		    if (token) {
+		      this.stream = this.stream.slice(token.length);
+		      return token;
+		    }
+		  };
+	
+		  /**
+		   * The implementation of token peeking.
+		   *
+		   * @returns {?Token}
+		   */
+	
+	
+		  HtmlParser.prototype._peekTokenImpl = function _peekTokenImpl() {
+		    for (var type in detect) {
+		      if (detect.hasOwnProperty(type)) {
+		        if (detect[type].test(this.stream)) {
+		          var token = streamReaders[type](this.stream);
+	
+		          if (token) {
+		            if (token.type === 'startTag' && /script|style/i.test(token.tagName)) {
+		              return null;
+		            } else {
+		              token.text = this.stream.substr(0, token.length);
+		              return token;
+		            }
+		          }
+		        }
+		      }
+		    }
+		  };
+	
+		  /**
+		   * The public token peeking interface.  Delegates to the basic token peeking
+		   * or a version that performs fixups depending on the `autoFix` setting in
+		   * options.
+		   *
+		   * @returns {object}
+		   */
+	
+	
+		  HtmlParser.prototype.peekToken = function peekToken() {
+		    return this._peekToken();
+		  };
+	
+		  /**
+		   * The public token reading interface.  Delegates to the basic token reading
+		   * or a version that performs fixups depending on the `autoFix` setting in
+		   * options.
+		   *
+		   * @returns {object}
+		   */
+	
+	
+		  HtmlParser.prototype.readToken = function readToken() {
+		    return this._readToken();
+		  };
+	
+		  /**
+		   * Read tokens and hand to the given handlers.
+		   *
+		   * @param {Object} handlers The handlers to use for the different tokens.
+		   */
+	
+	
+		  HtmlParser.prototype.readTokens = function readTokens(handlers) {
+		    var tok = void 0;
+		    while (tok = this.readToken()) {
+		      // continue until we get an explicit "false" return
+		      if (handlers[tok.type] && handlers[tok.type](tok) === false) {
+		        return;
+		      }
+		    }
+		  };
+	
+		  /**
+		   * Clears the parse stream.
+		   *
+		   * @returns {string} The contents of the parse stream before clearing.
+		   */
+	
+	
+		  HtmlParser.prototype.clear = function clear() {
+		    var rest = this.stream;
+		    this.stream = '';
+		    return rest;
+		  };
+	
+		  /**
+		   * Returns the rest of the parse stream.
+		   *
+		   * @returns {string} The contents of the parse stream.
+		   */
+	
+	
+		  HtmlParser.prototype.rest = function rest() {
+		    return this.stream;
+		  };
+	
+		  return HtmlParser;
+		}();
+	
+		exports['default'] = HtmlParser;
+	
+	
+		HtmlParser.tokenToString = function (tok) {
+		  return tok.toString();
+		};
+	
+		HtmlParser.escapeAttributes = function (attrs) {
+		  var escapedAttrs = {};
+	
+		  for (var name in attrs) {
+		    if (attrs.hasOwnProperty(name)) {
+		      escapedAttrs[name] = (0, _utils.escapeQuotes)(attrs[name], null);
+		    }
+		  }
+	
+		  return escapedAttrs;
+		};
+	
+		HtmlParser.supports = supports;
+	
+		for (var key in supports) {
+		  if (supports.hasOwnProperty(key)) {
+		    HtmlParser.browserHasFlaw = HtmlParser.browserHasFlaw || !supports[key] && key;
+		  }
+		}
+	
+	/***/ },
+	/* 2 */
+	/***/ function(module, exports) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+		var tagSoup = false;
+		var selfClose = false;
+	
+		var work = window.document.createElement('div');
+	
+		try {
+		  var html = '<P><I></P></I>';
+		  work.innerHTML = html;
+		  exports.tagSoup = tagSoup = work.innerHTML !== html;
+		} catch (e) {
+		  exports.tagSoup = tagSoup = false;
+		}
+	
+		try {
+		  work.innerHTML = '<P><i><P></P></i></P>';
+		  exports.selfClose = selfClose = work.childNodes.length === 2;
+		} catch (e) {
+		  exports.selfClose = selfClose = false;
+		}
+	
+		work = null;
+	
+		exports.tagSoup = tagSoup;
+		exports.selfClose = selfClose;
+	
+	/***/ },
+	/* 3 */
+	/***/ function(module, exports, __nested_webpack_require_35326__) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+	
+		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; };
+	
+		exports.comment = comment;
+		exports.chars = chars;
+		exports.startTag = startTag;
+		exports.atomicTag = atomicTag;
+		exports.endTag = endTag;
+	
+		var _tokens = __nested_webpack_require_35326__(4);
+	
+		/**
+		 * Regular Expressions for parsing tags and attributes
+		 *
+		 * @type {Object}
+		 */
+		var REGEXES = {
+		  startTag: /^<([\-A-Za-z0-9_]+)((?:\s+[\w\-]+(?:\s*=?\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/,
+		  endTag: /^<\/([\-A-Za-z0-9_]+)[^>]*>/,
+		  attr: /(?:([\-A-Za-z0-9_]+)\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))|(?:([\-A-Za-z0-9_]+)(\s|$)+)/g,
+		  fillAttr: /^(checked|compact|declare|defer|disabled|ismap|multiple|nohref|noresize|noshade|nowrap|readonly|selected)$/i
+		};
+	
+		/**
+		 * Reads a comment token
+		 *
+		 * @param {string} stream The input stream
+		 * @returns {CommentToken}
+		 */
+		function comment(stream) {
+		  var index = stream.indexOf('-->');
+		  if (index >= 0) {
+		    return new _tokens.CommentToken(stream.substr(4, index - 1), index + 3);
+		  }
+		}
+	
+		/**
+		 * Reads non-tag characters.
+		 *
+		 * @param {string} stream The input stream
+		 * @returns {CharsToken}
+		 */
+		function chars(stream) {
+		  var index = stream.indexOf('<');
+		  return new _tokens.CharsToken(index >= 0 ? index : stream.length);
+		}
+	
+		/**
+		 * Reads start tag token.
+		 *
+		 * @param {string} stream The input stream
+		 * @returns {StartTagToken}
+		 */
+		function startTag(stream) {
+		  var endTagIndex = stream.indexOf('>');
+		  if (endTagIndex !== -1) {
+		    var match = stream.match(REGEXES.startTag);
+		    if (match) {
+		      var _ret = function () {
+		        var attrs = {};
+		        var booleanAttrs = {};
+		        var rest = match[2];
+	
+		        match[2].replace(REGEXES.attr, function (match, name) {
+		          if (!(arguments[2] || arguments[3] || arguments[4] || arguments[5])) {
+		            attrs[name] = '';
+		          } else if (arguments[5]) {
+		            attrs[arguments[5]] = '';
+		            booleanAttrs[arguments[5]] = true;
+		          } else {
+		            attrs[name] = arguments[2] || arguments[3] || arguments[4] || REGEXES.fillAttr.test(name) && name || '';
+		          }
+	
+		          rest = rest.replace(match, '');
+		        });
+	
+		        return {
+		          v: new _tokens.StartTagToken(match[1], match[0].length, attrs, booleanAttrs, !!match[3], rest.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''))
+		        };
+		      }();
+	
+		      if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
+		    }
+		  }
+		}
+	
+		/**
+		 * Reads atomic tag token.
+		 *
+		 * @param {string} stream The input stream
+		 * @returns {AtomicTagToken}
+		 */
+		function atomicTag(stream) {
+		  var start = startTag(stream);
+		  if (start) {
+		    var rest = stream.slice(start.length);
+		    // for optimization, we check first just for the end tag
+		    if (rest.match(new RegExp('<\/\\s*' + start.tagName + '\\s*>', 'i'))) {
+		      // capturing the content is inefficient, so we do it inside the if
+		      var match = rest.match(new RegExp('([\\s\\S]*?)<\/\\s*' + start.tagName + '\\s*>', 'i'));
+		      if (match) {
+		        return new _tokens.AtomicTagToken(start.tagName, match[0].length + start.length, start.attrs, start.booleanAttrs, match[1]);
+		      }
+		    }
+		  }
+		}
+	
+		/**
+		 * Reads an end tag token.
+		 *
+		 * @param {string} stream The input stream
+		 * @returns {EndTagToken}
+		 */
+		function endTag(stream) {
+		  var match = stream.match(REGEXES.endTag);
+		  if (match) {
+		    return new _tokens.EndTagToken(match[1], match[0].length);
+		  }
+		}
+	
+	/***/ },
+	/* 4 */
+	/***/ function(module, exports, __nested_webpack_require_39304__) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+		exports.EndTagToken = exports.AtomicTagToken = exports.StartTagToken = exports.TagToken = exports.CharsToken = exports.CommentToken = exports.Token = undefined;
+	
+		var _utils = __nested_webpack_require_39304__(5);
+	
+		function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+	
+		/**
+		 * Token is a base class for all token types parsed.  Note we don't actually
+		 * use intheritance due to IE8's non-existent ES5 support.
+		 */
+		var Token =
+		/**
+		 * Constructor.
+		 *
+		 * @param {string} type The type of the Token.
+		 * @param {Number} length The length of the Token text.
+		 */
+		exports.Token = function Token(type, length) {
+		  _classCallCheck(this, Token);
+	
+		  this.type = type;
+		  this.length = length;
+		  this.text = '';
+		};
+	
+		/**
+		 * CommentToken represents comment tags.
+		 */
+	
+	
+		var CommentToken = exports.CommentToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} content The content of the comment
+		   * @param {Number} length The length of the Token text.
+		   */
+		  function CommentToken(content, length) {
+		    _classCallCheck(this, CommentToken);
+	
+		    this.type = 'comment';
+		    this.length = length || (content ? content.length : 0);
+		    this.text = '';
+		    this.content = content;
+		  }
+	
+		  CommentToken.prototype.toString = function toString() {
+		    return '<!--' + this.content;
+		  };
+	
+		  return CommentToken;
+		}();
+	
+		/**
+		 * CharsToken represents non-tag characters.
+		 */
+	
+	
+		var CharsToken = exports.CharsToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {Number} length The length of the Token text.
+		   */
+		  function CharsToken(length) {
+		    _classCallCheck(this, CharsToken);
+	
+		    this.type = 'chars';
+		    this.length = length;
+		    this.text = '';
+		  }
+	
+		  CharsToken.prototype.toString = function toString() {
+		    return this.text;
+		  };
+	
+		  return CharsToken;
+		}();
+	
+		/**
+		 * TagToken is a base class for all tag-based Tokens.
+		 */
+	
+	
+		var TagToken = exports.TagToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} type The type of the token.
+		   * @param {string} tagName The tag name.
+		   * @param {Number} length The length of the Token text.
+		   * @param {Object} attrs The dictionary of attributes and values
+		   * @param {Object} booleanAttrs If an entry has 'true' then the attribute
+		   *                              is a boolean attribute
+		   */
+		  function TagToken(type, tagName, length, attrs, booleanAttrs) {
+		    _classCallCheck(this, TagToken);
+	
+		    this.type = type;
+		    this.length = length;
+		    this.text = '';
+		    this.tagName = tagName;
+		    this.attrs = attrs;
+		    this.booleanAttrs = booleanAttrs;
+		    this.unary = false;
+		    this.html5Unary = false;
+		  }
+	
+		  /**
+		   * Formats the given token tag.
+		   *
+		   * @param {TagToken} tok The TagToken to format.
+		   * @param {?string} [content=null] The content of the token.
+		   * @returns {string} The formatted tag.
+		   */
+	
+	
+		  TagToken.formatTag = function formatTag(tok) {
+		    var content = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+	
+		    var str = '<' + tok.tagName;
+		    for (var key in tok.attrs) {
+		      if (tok.attrs.hasOwnProperty(key)) {
+		        str += ' ' + key;
+	
+		        var val = tok.attrs[key];
+		        if (typeof tok.booleanAttrs === 'undefined' || typeof tok.booleanAttrs[key] === 'undefined') {
+		          str += '="' + (0, _utils.escapeQuotes)(val) + '"';
+		        }
+		      }
+		    }
+	
+		    if (tok.rest) {
+		      str += ' ' + tok.rest;
+		    }
+	
+		    if (tok.unary && !tok.html5Unary) {
+		      str += '/>';
+		    } else {
+		      str += '>';
+		    }
+	
+		    if (content !== undefined && content !== null) {
+		      str += content + '</' + tok.tagName + '>';
+		    }
+	
+		    return str;
+		  };
+	
+		  return TagToken;
+		}();
+	
+		/**
+		 * StartTagToken represents a start token.
+		 */
+	
+	
+		var StartTagToken = exports.StartTagToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} tagName The tag name.
+		   * @param {Number} length The length of the Token text
+		   * @param {Object} attrs The dictionary of attributes and values
+		   * @param {Object} booleanAttrs If an entry has 'true' then the attribute
+		   *                              is a boolean attribute
+		   * @param {boolean} unary True if the tag is a unary tag
+		   * @param {string} rest The rest of the content.
+		   */
+		  function StartTagToken(tagName, length, attrs, booleanAttrs, unary, rest) {
+		    _classCallCheck(this, StartTagToken);
+	
+		    this.type = 'startTag';
+		    this.length = length;
+		    this.text = '';
+		    this.tagName = tagName;
+		    this.attrs = attrs;
+		    this.booleanAttrs = booleanAttrs;
+		    this.html5Unary = false;
+		    this.unary = unary;
+		    this.rest = rest;
+		  }
+	
+		  StartTagToken.prototype.toString = function toString() {
+		    return TagToken.formatTag(this);
+		  };
+	
+		  return StartTagToken;
+		}();
+	
+		/**
+		 * AtomicTagToken represents an atomic tag.
+		 */
+	
+	
+		var AtomicTagToken = exports.AtomicTagToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} tagName The name of the tag.
+		   * @param {Number} length The length of the tag text.
+		   * @param {Object} attrs The attributes.
+		   * @param {Object} booleanAttrs If an entry has 'true' then the attribute
+		   *                              is a boolean attribute
+		   * @param {string} content The content of the tag.
+		   */
+		  function AtomicTagToken(tagName, length, attrs, booleanAttrs, content) {
+		    _classCallCheck(this, AtomicTagToken);
+	
+		    this.type = 'atomicTag';
+		    this.length = length;
+		    this.text = '';
+		    this.tagName = tagName;
+		    this.attrs = attrs;
+		    this.booleanAttrs = booleanAttrs;
+		    this.unary = false;
+		    this.html5Unary = false;
+		    this.content = content;
+		  }
+	
+		  AtomicTagToken.prototype.toString = function toString() {
+		    return TagToken.formatTag(this, this.content);
+		  };
+	
+		  return AtomicTagToken;
+		}();
+	
+		/**
+		 * EndTagToken represents an end tag.
+		 */
+	
+	
+		var EndTagToken = exports.EndTagToken = function () {
+		  /**
+		   * Constructor.
+		   *
+		   * @param {string} tagName The name of the tag.
+		   * @param {Number} length The length of the tag text.
+		   */
+		  function EndTagToken(tagName, length) {
+		    _classCallCheck(this, EndTagToken);
+	
+		    this.type = 'endTag';
+		    this.length = length;
+		    this.text = '';
+		    this.tagName = tagName;
+		  }
+	
+		  EndTagToken.prototype.toString = function toString() {
+		    return '</' + this.tagName + '>';
+		  };
+	
+		  return EndTagToken;
+		}();
+	
+	/***/ },
+	/* 5 */
+	/***/ function(module, exports) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+		exports.escapeQuotes = escapeQuotes;
+	
+		/**
+		 * Escape quotes in the given value.
+		 *
+		 * @param {string} value The value to escape.
+		 * @param {string} [defaultValue=''] The default value to return if value is falsy.
+		 * @returns {string}
+		 */
+		function escapeQuotes(value) {
+		  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+	
+		  // There's no lookback in JS, so /(^|[^\\])"/ only matches the first of two `"`s.
+		  // Instead, just match anything before a double-quote and escape if it's not already escaped.
+		  return !value ? defaultValue : value.replace(/([^"]*)"/g, function (_, prefix) {
+		    return (/\\/.test(prefix) ? prefix + '"' : prefix + '\\"'
+		    );
+		  });
+		}
+	
+	/***/ },
+	/* 6 */
+	/***/ function(module, exports) {
+	
+		'use strict';
+	
+		exports.__esModule = true;
+		exports['default'] = fixedReadTokenFactory;
+		/**
+		 * Empty Elements - HTML 4.01
+		 *
+		 * @type {RegExp}
+		 */
+		var EMPTY = /^(AREA|BASE|BASEFONT|BR|COL|FRAME|HR|IMG|INPUT|ISINDEX|LINK|META|PARAM|EMBED)$/i;
+	
+		/**
+		 * Elements that you can intentionally leave open (and which close themselves)
+		 *
+		 * @type {RegExp}
+		 */
+		var CLOSESELF = /^(COLGROUP|DD|DT|LI|OPTIONS|P|TD|TFOOT|TH|THEAD|TR)$/i;
+	
+		/**
+		 * Corrects a token.
+		 *
+		 * @param {Token} tok The token to correct
+		 * @returns {Token} The corrected token
+		 */
+		function correct(tok) {
+		  if (tok && tok.type === 'startTag') {
+		    tok.unary = EMPTY.test(tok.tagName) || tok.unary;
+		    tok.html5Unary = !/\/>$/.test(tok.text);
+		  }
+		  return tok;
+		}
+	
+		/**
+		 * Peeks at the next token in the parser.
+		 *
+		 * @param {HtmlParser} parser The parser
+		 * @param {Function} readTokenImpl The underlying readToken implementation
+		 * @returns {Token} The next token
+		 */
+		function peekToken(parser, readTokenImpl) {
+		  var tmp = parser.stream;
+		  var tok = correct(readTokenImpl());
+		  parser.stream = tmp;
+		  return tok;
+		}
+	
+		/**
+		 * Closes the last token.
+		 *
+		 * @param {HtmlParser} parser The parser
+		 * @param {Array<Token>} stack The stack
+		 */
+		function closeLast(parser, stack) {
+		  var tok = stack.pop();
+	
+		  // prepend close tag to stream.
+		  parser.prepend('</' + tok.tagName + '>');
+		}
+	
+		/**
+		 * Create a new token stack.
+		 *
+		 * @returns {Array<Token>}
+		 */
+		function newStack() {
+		  var stack = [];
+	
+		  stack.last = function () {
+		    return this[this.length - 1];
+		  };
+	
+		  stack.lastTagNameEq = function (tagName) {
+		    var last = this.last();
+		    return last && last.tagName && last.tagName.toUpperCase() === tagName.toUpperCase();
+		  };
+	
+		  stack.containsTagName = function (tagName) {
+		    for (var i = 0, tok; tok = this[i]; i++) {
+		      if (tok.tagName === tagName) {
+		        return true;
+		      }
+		    }
+		    return false;
+		  };
+	
+		  return stack;
+		}
+	
+		/**
+		 * Return a readToken implementation that fixes input.
+		 *
+		 * @param {HtmlParser} parser The parser
+		 * @param {Object} options Options for fixing
+		 * @param {boolean} options.tagSoupFix True to fix tag soup scenarios
+		 * @param {boolean} options.selfCloseFix True to fix self-closing tags
+		 * @param {Function} readTokenImpl The underlying readToken implementation
+		 * @returns {Function}
+		 */
+		function fixedReadTokenFactory(parser, options, readTokenImpl) {
+		  var stack = newStack();
+	
+		  var handlers = {
+		    startTag: function startTag(tok) {
+		      var tagName = tok.tagName;
+	
+		      if (tagName.toUpperCase() === 'TR' && stack.lastTagNameEq('TABLE')) {
+		        parser.prepend('<TBODY>');
+		        prepareNextToken();
+		      } else if (options.selfCloseFix && CLOSESELF.test(tagName) && stack.containsTagName(tagName)) {
+		        if (stack.lastTagNameEq(tagName)) {
+		          closeLast(parser, stack);
+		        } else {
+		          parser.prepend('</' + tok.tagName + '>');
+		          prepareNextToken();
+		        }
+		      } else if (!tok.unary) {
+		        stack.push(tok);
+		      }
+		    },
+		    endTag: function endTag(tok) {
+		      var last = stack.last();
+		      if (last) {
+		        if (options.tagSoupFix && !stack.lastTagNameEq(tok.tagName)) {
+		          // cleanup tag soup
+		          closeLast(parser, stack);
+		        } else {
+		          stack.pop();
+		        }
+		      } else if (options.tagSoupFix) {
+		        // cleanup tag soup part 2: skip this token
+		        readTokenImpl();
+		        prepareNextToken();
+		      }
+		    }
+		  };
+	
+		  function prepareNextToken() {
+		    var tok = peekToken(parser, readTokenImpl);
+		    if (tok && handlers[tok.type]) {
+		      handlers[tok.type](tok);
+		    }
+		  }
+	
+		  return function fixedReadToken() {
+		    prepareNextToken();
+		    return correct(readTokenImpl());
+		  };
+		}
+	
+	/***/ }
+	/******/ ])
+	});
+	;
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	'use strict';
+	
+	exports.__esModule = true;
+	
+	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; };
+	
+	exports.existy = existy;
+	exports.isFunction = isFunction;
+	exports.each = each;
+	exports.eachKey = eachKey;
+	exports.defaults = defaults;
+	exports.toArray = toArray;
+	exports.last = last;
+	exports.isTag = isTag;
+	exports.isScript = isScript;
+	exports.isStyle = isStyle;
+	/**
+	 * Determine if the thing is not undefined and not null.
+	 *
+	 * @param {*} thing The thing to test
+	 * @returns {boolean} True if the thing is not undefined and not null.
+	 */
+	function existy(thing) {
+	  return thing !== void 0 && thing !== null;
+	}
+	
+	/**
+	 * Is this a function?
+	 *
+	 * @param {*} x The variable to test
+	 * @returns {boolean} True if the variable is a function
+	 */
+	function isFunction(x) {
+	  return 'function' === typeof x;
+	}
+	
+	/**
+	 * Loop over each item in an array-like value.
+	 *
+	 * @param {Array<*>} arr The array to loop over
+	 * @param {Function} fn The function to call
+	 * @param {?Object} target The object to bind to the function
+	 */
+	function each(arr, fn, target) {
+	  var i = void 0;
+	  var len = arr && arr.length || 0;
+	  for (i = 0; i < len; i++) {
+	    fn.call(target, arr[i], i);
+	  }
+	}
+	
+	/**
+	 * Loop over each key/value pair in a hash.
+	 *
+	 * @param {Object} obj The object
+	 * @param {Function} fn The function to call
+	 * @param {?Object} target The object to bind to the function
+	 */
+	function eachKey(obj, fn, target) {
+	  for (var key in obj) {
+	    if (obj.hasOwnProperty(key)) {
+	      fn.call(target, key, obj[key]);
+	    }
+	  }
+	}
+	
+	/**
+	 * Set default options where some option was not specified.
+	 *
+	 * @param {Object} options The destination
+	 * @param {Object} _defaults The defaults
+	 * @returns {Object}
+	 */
+	function defaults(options, _defaults) {
+	  options = options || {};
+	  eachKey(_defaults, function (key, val) {
+	    if (!existy(options[key])) {
+	      options[key] = val;
+	    }
+	  });
+	  return options;
+	}
+	
+	/**
+	 * Convert value (e.g., a NodeList) to an array.
+	 *
+	 * @param {*} obj The object
+	 * @returns {Array<*>}
+	 */
+	function toArray(obj) {
+	  try {
+	    return Array.prototype.slice.call(obj);
+	  } catch (e) {
+	    var _ret = function () {
+	      var ret = [];
+	      each(obj, function (val) {
+	        ret.push(val);
+	      });
+	      return {
+	        v: ret
+	      };
+	    }();
+	
+	    if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
+	  }
+	}
+	
+	/**
+	 * Get the last item in an array
+	 *
+	 * @param {Array<*>} array The array
+	 * @returns {*} The last item in the array
+	 */
+	function last(array) {
+	  return array[array.length - 1];
+	}
+	
+	/**
+	 * Test if token is a script tag.
+	 *
+	 * @param {Object} tok The token
+	 * @param {String} tag The tag name
+	 * @returns {boolean} True if the token is a script tag
+	 */
+	function isTag(tok, tag) {
+	  return !tok || !(tok.type === 'startTag' || tok.type === 'atomicTag') || !('tagName' in tok) ? !1 : !!~tok.tagName.toLowerCase().indexOf(tag);
+	}
+	
+	/**
+	 * Test if token is a script tag.
+	 *
+	 * @param {Object} tok The token
+	 * @returns {boolean} True if the token is a script tag
+	 */
+	function isScript(tok) {
+	  return isTag(tok, 'script');
+	}
+	
+	/**
+	 * Test if token is a style tag.
+	 *
+	 * @param {Object} tok The token
+	 * @returns {boolean} True if the token is a style tag
+	 */
+	function isStyle(tok) {
+	  return isTag(tok, 'style');
+	}
+
+/***/ }
+/******/ ])
+});
+;
+//# sourceMappingURL=postscribe.js.map
+
+/***/ })
+/******/ 	]);
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
+!function() {
+"use strict";
+
+
+var _utils = __webpack_require__(1);
+var _renderingManager = __webpack_require__(3);
+var _mobileAndAmpRender = __webpack_require__(7);
+var _environment = __webpack_require__(4);
+/**
+* legacy.js
+* This is deprecated code, publishers should not use one .js creative to handle all different types of creative.
+* To reduce bytes transfered for each ad, publishers should use specific .js based on hb_format targeting key-value.
+*
+* This file is inserted into the prebid creative as a placeholder for the winning prebid creative. It should support the following formats:
+* - Banner
+* - AMP
+* - Mobile
+* - Outstream Video
+* - All safeFrame creatives
+*/
+
+window.ucTag = window.ucTag || {};
+window.ucTag.renderAd = function (doc, dataObject) {
+  var targetingData = (0, _utils.transformAuctionTargetingData)(dataObject);
+  if ((0, _environment.isMobileApp)(targetingData.env) || (0, _environment.isAmp)(targetingData.uuid, window)) {
+    (0, _mobileAndAmpRender.renderAmpOrMobileAd)(dataObject);
+  } else {
+    (0, _renderingManager.renderBannerOrDisplayAd)(doc, dataObject);
+  }
+};
+}();
+/******/ })()
+;