@oiz/stzh-components 4.9.0-beta2 → 4.9.0-beta4

package/dist/components/p-CF0Eco5y.js

@@ -0,0 +1,3120 @@
+import { p as proxyCustomElement, H, d as createEvent, h, e as Host, t as transformTag } from './p-BOU3cRYl.js';
+import { a as api } from './p-Cpg2gH_9.js';
+import { g as getDefaultExportFromCjs } from './p-E-ZsRS8r.js';
+import { d as defineCustomElement$3 } from './p-6ax-mKBx.js';
+import { d as defineCustomElement$2 } from './p-8LohUgRI.js';
+import { d as defineCustomElement$1 } from './p-DkuigYKB.js';
+
+var iframeResizer$1 = {exports: {}};
+
+/*
+ * File: iframeResizer.js
+ * Desc: Force iframes to size to content.
+ * Requires: iframeResizer.contentWindow.js to be loaded into the target frame.
+ * Doc: https://iframe-resizer.com
+ * Author: David J. Bradshaw - info@iframe-resizer.com
+ */
+
+var hasRequiredIframeResizer$1;
+
+function requireIframeResizer$1 () {
+	if (hasRequiredIframeResizer$1) return iframeResizer$1.exports;
+	hasRequiredIframeResizer$1 = 1;
+	(function (module) {
+		console.info(`
+IFRAME-RESIZER
+
+Iframe-Resizer 5 is now available via the following two packages:
+
+ * @iframe-resizer/parent
+ * @iframe-resizer/child
+
+Additionally their are also new versions of iframe-resizer for React, Vue, and jQuery.
+
+Version 5 of iframe-resizer has been extensively rewritten to use modern browser APIs, which has enabled significantly better performance and greater accuracy in the detection of content resizing events.
+
+Please see https://iframe-resizer.com/upgrade for more details.
+`)
+
+		// eslint-disable-next-line sonarjs/cognitive-complexity, no-shadow-restricted-names
+		;(function (undefined$1) {
+		  if (typeof window === 'undefined') return // don't run for server side render
+
+		  // var VERSION = '4.3.11'
+
+		  var count = 0,
+		    destroyObserver,
+		    logEnabled = false,
+		    hiddenCheckEnabled = false,
+		    msgHeader = 'message',
+		    msgHeaderLen = msgHeader.length,
+		    msgId = '[iFrameSizer]', // Must match iframe msg ID
+		    msgIdLen = msgId.length,
+		    pagePosition = null,
+		    requestAnimationFrame = window.requestAnimationFrame,
+		    resetRequiredMethods = Object.freeze({
+		      max: 1,
+		      scroll: 1,
+		      bodyScroll: 1,
+		      documentElementScroll: 1
+		    }),
+		    settings = {},
+		    timer = null,
+		    defaults = Object.freeze({
+		      autoResize: true,
+		      bodyBackground: null,
+		      bodyMargin: null,
+		      bodyMarginV1: 8,
+		      bodyPadding: null,
+		      checkOrigin: true,
+		      inPageLinks: false,
+		      enablePublicMethods: true,
+		      heightCalculationMethod: 'bodyOffset',
+		      id: 'iFrameResizer',
+		      interval: 32,
+		      license: '1jqr0si6pnt',
+		      log: false,
+		      maxHeight: Infinity,
+		      maxWidth: Infinity,
+		      minHeight: 0,
+		      minWidth: 0,
+		      mouseEvents: true,
+		      resizeFrom: 'parent',
+		      scrolling: false,
+		      sizeHeight: true,
+		      sizeWidth: false,
+		      warningTimeout: 5000,
+		      tolerance: 0,
+		      widthCalculationMethod: 'scroll',
+		      onClose: function () {
+		        return true
+		      },
+		      onClosed: function () {},
+		      onInit: function () {},
+		      onMessage: function () {
+		        warn('onMessage function not defined');
+		      },
+		      onMouseEnter: function () {},
+		      onMouseLeave: function () {},
+		      onResized: function () {},
+		      onScroll: function () {
+		        return true
+		      }
+		    });
+
+		  function getMutationObserver() {
+		    return (
+		      window.MutationObserver ||
+		      window.WebKitMutationObserver ||
+		      window.MozMutationObserver
+		    )
+		  }
+
+		  function addEventListener(el, evt, func) {
+		    el.addEventListener(evt, func, false);
+		  }
+
+		  function removeEventListener(el, evt, func) {
+		    el.removeEventListener(evt, func, false);
+		  }
+
+		  function setupRequestAnimationFrame() {
+		    var vendors = ['moz', 'webkit', 'o', 'ms'];
+		    var x;
+
+		    // Remove vendor prefixing if prefixed and break early if not
+		    for (x = 0; x < vendors.length && !requestAnimationFrame; x += 1) {
+		      requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
+		    }
+
+		    if (requestAnimationFrame) {
+		      // Firefox extension content-scripts have a globalThis object that is not the same as window.
+		      // Binding `requestAnimationFrame` to window allows the function to work and prevents errors
+		      // being thrown when run in that context, and should be a no-op in every other context.
+		      requestAnimationFrame = requestAnimationFrame.bind(window);
+		    } else {
+		      log('setup', 'RequestAnimationFrame not supported');
+		    }
+		  }
+
+		  function getMyID(iframeId) {
+		    var retStr = 'Host page: ' + iframeId;
+
+		    if (window.top !== window.self) {
+		      retStr =
+		        window.parentIFrame && window.parentIFrame.getId
+		          ? window.parentIFrame.getId() + ': ' + iframeId
+		          : 'Nested host page: ' + iframeId;
+		    }
+
+		    return retStr
+		  }
+
+		  function formatLogHeader(iframeId) {
+		    return msgId + '[' + getMyID(iframeId) + ']'
+		  }
+
+		  function isLogEnabled(iframeId) {
+		    return settings[iframeId] ? settings[iframeId].log : logEnabled
+		  }
+
+		  function log(iframeId, msg) {
+		    output('log', iframeId, msg, isLogEnabled(iframeId));
+		  }
+
+		  function info(iframeId, msg) {
+		    output('info', iframeId, msg, isLogEnabled(iframeId));
+		  }
+
+		  function warn(iframeId, msg) {
+		    output('warn', iframeId, msg, true);
+		  }
+
+		  function output(type, iframeId, msg, enabled) {
+		    if (true === enabled && 'object' === typeof window.console) {
+		      // eslint-disable-next-line no-console
+		      console[type](formatLogHeader(iframeId), msg);
+		    }
+		  }
+
+		  function iFrameListener(event) {
+		    function resizeIFrame() {
+		      function resize() {
+		        setSize(messageData);
+		        setPagePosition(iframeId);
+		        on('onResized', messageData);
+		      }
+
+		      ensureInRange('Height');
+		      ensureInRange('Width');
+
+		      syncResize(resize, messageData, 'init');
+		    }
+
+		    function processMsg() {
+		      var data = msg.slice(msgIdLen).split(':');
+		      var height = data[1] ? parseInt(data[1], 10) : 0;
+		      var iframe = settings[data[0]] && settings[data[0]].iframe;
+		      var compStyle = getComputedStyle(iframe);
+
+		      return {
+		        iframe: iframe,
+		        id: data[0],
+		        height: height + getPaddingEnds(compStyle) + getBorderEnds(compStyle),
+		        width: data[2],
+		        type: data[3]
+		      }
+		    }
+
+		    function getPaddingEnds(compStyle) {
+		      if (compStyle.boxSizing !== 'border-box') {
+		        return 0
+		      }
+		      var top = compStyle.paddingTop ? parseInt(compStyle.paddingTop, 10) : 0;
+		      var bot = compStyle.paddingBottom
+		        ? parseInt(compStyle.paddingBottom, 10)
+		        : 0;
+		      return top + bot
+		    }
+
+		    function getBorderEnds(compStyle) {
+		      if (compStyle.boxSizing !== 'border-box') {
+		        return 0
+		      }
+		      var top = compStyle.borderTopWidth
+		        ? parseInt(compStyle.borderTopWidth, 10)
+		        : 0;
+		      var bot = compStyle.borderBottomWidth
+		        ? parseInt(compStyle.borderBottomWidth, 10)
+		        : 0;
+		      return top + bot
+		    }
+
+		    function ensureInRange(Dimension) {
+		      var max = Number(settings[iframeId]['max' + Dimension]),
+		        min = Number(settings[iframeId]['min' + Dimension]),
+		        dimension = Dimension.toLowerCase(),
+		        size = Number(messageData[dimension]);
+
+		      log(iframeId, 'Checking ' + dimension + ' is in range ' + min + '-' + max);
+
+		      if (size < min) {
+		        size = min;
+		        log(iframeId, 'Set ' + dimension + ' to min value');
+		      }
+
+		      if (size > max) {
+		        size = max;
+		        log(iframeId, 'Set ' + dimension + ' to max value');
+		      }
+
+		      messageData[dimension] = '' + size;
+		    }
+
+		    function isMessageFromIFrame() {
+		      function checkAllowedOrigin() {
+		        function checkList() {
+		          var i = 0,
+		            retCode = false;
+
+		          log(
+		            iframeId,
+		            'Checking connection is from allowed list of origins: ' +
+		              checkOrigin
+		          );
+
+		          for (; i < checkOrigin.length; i++) {
+		            if (checkOrigin[i] === origin) {
+		              retCode = true;
+		              break
+		            }
+		          }
+		          return retCode
+		        }
+
+		        function checkSingle() {
+		          var remoteHost = settings[iframeId] && settings[iframeId].remoteHost;
+		          log(iframeId, 'Checking connection is from: ' + remoteHost);
+		          return origin === remoteHost
+		        }
+
+		        return checkOrigin.constructor === Array ? checkList() : checkSingle()
+		      }
+
+		      var origin = event.origin,
+		        checkOrigin = settings[iframeId] && settings[iframeId].checkOrigin;
+
+		      if (checkOrigin && '' + origin !== 'null' && !checkAllowedOrigin()) {
+		        throw new Error(
+		          'Unexpected message received from: ' +
+		            origin +
+		            ' for ' +
+		            messageData.iframe.id +
+		            '. Message was: ' +
+		            event.data +
+		            '. This error can be disabled by setting the checkOrigin: false option or by providing of array of trusted domains.'
+		        )
+		      }
+
+		      return true
+		    }
+
+		    function isMessageForUs() {
+		      return (
+		        msgId === ('' + msg).slice(0, msgIdLen) &&
+		        msg.slice(msgIdLen).split(':')[0] in settings
+		      ) // ''+Protects against non-string msg
+		    }
+
+		    function isMessageFromMetaParent() {
+		      // Test if this message is from a parent above us. This is an ugly test, however, updating
+		      // the message format would break backwards compatibility.
+		      var retCode = messageData.type in { true: 1, false: 1, undefined: 1 };
+
+		      if (retCode) {
+		        log(iframeId, 'Ignoring init message from meta parent page');
+		      }
+
+		      return retCode
+		    }
+
+		    function getMsgBody(offset) {
+		      return msg.slice(msg.indexOf(':') + msgHeaderLen + offset)
+		    }
+
+		    function forwardMsgFromIFrame(msgBody) {
+		      log(
+		        iframeId,
+		        'onMessage passed: {iframe: ' +
+		          messageData.iframe.id +
+		          ', message: ' +
+		          msgBody +
+		          '}'
+		      );
+
+		      on('onMessage', {
+		        iframe: messageData.iframe,
+		        message: JSON.parse(msgBody)
+		      });
+
+		      log(iframeId, '--');
+		    }
+
+		    function getPageInfo() {
+		      var bodyPosition = document.body.getBoundingClientRect(),
+		        iFramePosition = messageData.iframe.getBoundingClientRect();
+
+		      return JSON.stringify({
+		        iframeHeight: iFramePosition.height,
+		        iframeWidth: iFramePosition.width,
+		        clientHeight: Math.max(
+		          document.documentElement.clientHeight,
+		          window.innerHeight || 0
+		        ),
+		        clientWidth: Math.max(
+		          document.documentElement.clientWidth,
+		          window.innerWidth || 0
+		        ),
+		        offsetTop: parseInt(iFramePosition.top - bodyPosition.top, 10),
+		        offsetLeft: parseInt(iFramePosition.left - bodyPosition.left, 10),
+		        scrollTop: window.pageYOffset,
+		        scrollLeft: window.pageXOffset,
+		        documentHeight: document.documentElement.clientHeight,
+		        documentWidth: document.documentElement.clientWidth,
+		        windowHeight: window.innerHeight,
+		        windowWidth: window.innerWidth
+		      })
+		    }
+
+		    function sendPageInfoToIframe(iframe, iframeId) {
+		      function debouncedTrigger() {
+		        trigger('Send Page Info', 'pageInfo:' + getPageInfo(), iframe, iframeId);
+		      }
+		      debounceFrameEvents(debouncedTrigger, 32, iframeId);
+		    }
+
+		    function startPageInfoMonitor() {
+		      function setListener(type, func) {
+		        function sendPageInfo() {
+		          if (settings[id]) {
+		            sendPageInfoToIframe(settings[id].iframe, id);
+		          } else {
+		            stop();
+		          }
+		        }
+['scroll', 'resize'].forEach(function (evt) {
+		          log(id, type + evt + ' listener for sendPageInfo');
+		          func(window, evt, sendPageInfo);
+		        });
+		      }
+
+		      function stop() {
+		        setListener('Remove ', removeEventListener);
+		      }
+
+		      function start() {
+		        setListener('Add ', addEventListener);
+		      }
+
+		      var id = iframeId; // Create locally scoped copy of iFrame ID
+
+		      start();
+
+		      if (settings[id]) {
+		        settings[id].stopPageInfo = stop;
+		      }
+		    }
+
+		    function stopPageInfoMonitor() {
+		      if (settings[iframeId] && settings[iframeId].stopPageInfo) {
+		        settings[iframeId].stopPageInfo();
+		        delete settings[iframeId].stopPageInfo;
+		      }
+		    }
+
+		    function checkIFrameExists() {
+		      var retBool = true;
+
+		      if (null === messageData.iframe) {
+		        warn(iframeId, 'IFrame (' + messageData.id + ') not found');
+		        retBool = false;
+		      }
+		      return retBool
+		    }
+
+		    function getElementPosition(target) {
+		      var iFramePosition = target.getBoundingClientRect();
+
+		      getPagePosition(iframeId);
+
+		      return {
+		        x: Math.floor(Number(iFramePosition.left) + Number(pagePosition.x)),
+		        y: Math.floor(Number(iFramePosition.top) + Number(pagePosition.y))
+		      }
+		    }
+
+		    function scrollRequestFromChild(addOffset) {
+		      /* istanbul ignore next */ // Not testable in Karma
+		      function reposition() {
+		        pagePosition = newPosition;
+		        scrollTo();
+		        log(iframeId, '--');
+		      }
+
+		      function calcOffset() {
+		        return {
+		          x: Number(messageData.width) + offset.x,
+		          y: Number(messageData.height) + offset.y
+		        }
+		      }
+
+		      function scrollParent() {
+		        if (window.parentIFrame) {
+		          window.parentIFrame['scrollTo' + (addOffset ? 'Offset' : '')](
+		            newPosition.x,
+		            newPosition.y
+		          );
+		        } else {
+		          warn(
+		            iframeId,
+		            'Unable to scroll to requested position, window.parentIFrame not found'
+		          );
+		        }
+		      }
+
+		      var offset = addOffset
+		          ? getElementPosition(messageData.iframe)
+		          : { x: 0, y: 0 },
+		        newPosition = calcOffset();
+
+		      log(
+		        iframeId,
+		        'Reposition requested from iFrame (offset x:' +
+		          offset.x +
+		          ' y:' +
+		          offset.y +
+		          ')'
+		      );
+
+		      if (window.top === window.self) {
+		        reposition();
+		      } else {
+		        scrollParent();
+		      }
+		    }
+
+		    function scrollTo() {
+		      if (false === on('onScroll', pagePosition)) {
+		        unsetPagePosition();
+		      } else {
+		        setPagePosition(iframeId);
+		      }
+		    }
+
+		    function findTarget(location) {
+		      function jumpToTarget() {
+		        var jumpPosition = getElementPosition(target);
+
+		        log(
+		          iframeId,
+		          'Moving to in page link (#' +
+		            hash +
+		            ') at x: ' +
+		            jumpPosition.x +
+		            ' y: ' +
+		            jumpPosition.y
+		        );
+		        pagePosition = {
+		          x: jumpPosition.x,
+		          y: jumpPosition.y
+		        };
+
+		        scrollTo();
+		        log(iframeId, '--');
+		      }
+
+		      function jumpToParent() {
+		        if (window.parentIFrame) {
+		          window.parentIFrame.moveToAnchor(hash);
+		        } else {
+		          log(
+		            iframeId,
+		            'In page link #' +
+		              hash +
+		              ' not found and window.parentIFrame not found'
+		          );
+		        }
+		      }
+
+		      var hash = location.split('#')[1] || '',
+		        hashData = decodeURIComponent(hash),
+		        target =
+		          document.getElementById(hashData) ||
+		          document.getElementsByName(hashData)[0];
+
+		      if (target) {
+		        jumpToTarget();
+		      } else if (window.top === window.self) {
+		        log(iframeId, 'In page link #' + hash + ' not found');
+		      } else {
+		        jumpToParent();
+		      }
+		    }
+
+		    function onMouse(event) {
+		      var mousePos = {};
+
+		      if (Number(messageData.width) === 0 && Number(messageData.height) === 0) {
+		        var data = getMsgBody(9).split(':');
+		        mousePos = {
+		          x: data[1],
+		          y: data[0]
+		        };
+		      } else {
+		        mousePos = {
+		          x: messageData.width,
+		          y: messageData.height
+		        };
+		      }
+
+		      on(event, {
+		        iframe: messageData.iframe,
+		        screenX: Number(mousePos.x),
+		        screenY: Number(mousePos.y),
+		        type: messageData.type
+		      });
+		    }
+
+		    function on(funcName, val) {
+		      return chkEvent(iframeId, funcName, val)
+		    }
+
+		    function actionMsg() {
+		      if (settings[iframeId] && settings[iframeId].firstRun) firstRun();
+
+		      switch (messageData.type) {
+		        case 'close': {
+		          closeIFrame(messageData.iframe);
+		          break
+		        }
+
+		        case 'message': {
+		          forwardMsgFromIFrame(getMsgBody(6));
+		          break
+		        }
+
+		        case 'mouseenter': {
+		          onMouse('onMouseEnter');
+		          break
+		        }
+
+		        case 'mouseleave': {
+		          onMouse('onMouseLeave');
+		          break
+		        }
+
+		        case 'autoResize': {
+		          settings[iframeId].autoResize = JSON.parse(getMsgBody(9));
+		          break
+		        }
+
+		        case 'scrollTo': {
+		          scrollRequestFromChild(false);
+		          break
+		        }
+
+		        case 'scrollToOffset': {
+		          scrollRequestFromChild(true);
+		          break
+		        }
+
+		        case 'pageInfo': {
+		          sendPageInfoToIframe(
+		            settings[iframeId] && settings[iframeId].iframe,
+		            iframeId
+		          );
+		          startPageInfoMonitor();
+		          break
+		        }
+
+		        case 'pageInfoStop': {
+		          stopPageInfoMonitor();
+		          break
+		        }
+
+		        case 'inPageLink': {
+		          findTarget(getMsgBody(9));
+		          break
+		        }
+
+		        case 'reset': {
+		          resetIFrame(messageData);
+		          break
+		        }
+
+		        case 'init': {
+		          resizeIFrame();
+		          on('onInit', messageData.iframe);
+		          break
+		        }
+
+		        default: {
+		          if (
+		            Number(messageData.width) === 0 &&
+		            Number(messageData.height) === 0
+		          ) {
+		            warn(
+		              'Unsupported message received (' +
+		                messageData.type +
+		                '), this is likely due to the iframe containing a later ' +
+		                'version of iframe-resizer than the parent page'
+		            );
+		          } else {
+		            resizeIFrame();
+		          }
+		        }
+		      }
+		    }
+
+		    function hasSettings(iframeId) {
+		      var retBool = true;
+
+		      if (!settings[iframeId]) {
+		        retBool = false;
+		        warn(
+		          messageData.type +
+		            ' No settings for ' +
+		            iframeId +
+		            '. Message was: ' +
+		            msg
+		        );
+		      }
+
+		      return retBool
+		    }
+
+		    function iFrameReadyMsgReceived() {
+		      // eslint-disable-next-line no-restricted-syntax, guard-for-in
+		      for (var iframeId in settings) {
+		        trigger(
+		          'iFrame requested init',
+		          createOutgoingMsg(iframeId),
+		          settings[iframeId].iframe,
+		          iframeId
+		        );
+		      }
+		    }
+
+		    function firstRun() {
+		      if (settings[iframeId]) {
+		        settings[iframeId].firstRun = false;
+		      }
+		    }
+
+		    var msg = event.data,
+		      messageData = {},
+		      iframeId = null;
+
+		    if ('[iFrameResizerChild]Ready' === msg) {
+		      iFrameReadyMsgReceived();
+		    } else if (isMessageForUs()) {
+		      messageData = processMsg();
+		      iframeId = messageData.id;
+		      if (settings[iframeId]) {
+		        settings[iframeId].loaded = true;
+		      }
+
+		      if (!isMessageFromMetaParent() && hasSettings(iframeId)) {
+		        log(iframeId, 'Received: ' + msg);
+
+		        if (checkIFrameExists() && isMessageFromIFrame()) {
+		          actionMsg();
+		        }
+		      }
+		    } else {
+		      info(iframeId, 'Ignored: ' + msg);
+		    }
+		  }
+
+		  function chkEvent(iframeId, funcName, val) {
+		    var func = null,
+		      retVal = null;
+
+		    if (settings[iframeId]) {
+		      func = settings[iframeId][funcName];
+
+		      if ('function' === typeof func) {
+		        retVal = func(val);
+		      } else {
+		        throw new TypeError(
+		          funcName + ' on iFrame[' + iframeId + '] is not a function'
+		        )
+		      }
+		    }
+
+		    return retVal
+		  }
+
+		  function removeIframeListeners(iframe) {
+		    var iframeId = iframe.id;
+		    delete settings[iframeId];
+		  }
+
+		  function closeIFrame(iframe) {
+		    var iframeId = iframe.id;
+		    if (chkEvent(iframeId, 'onClose', iframeId) === false) {
+		      log(iframeId, 'Close iframe cancelled by onClose event');
+		      return
+		    }
+		    log(iframeId, 'Removing iFrame: ' + iframeId);
+
+		    try {
+		      // Catch race condition error with React
+		      if (iframe.parentNode) {
+		        iframe.parentNode.removeChild(iframe);
+		      }
+		    } catch (error) {
+		      warn(error);
+		    }
+
+		    chkEvent(iframeId, 'onClosed', iframeId);
+		    log(iframeId, '--');
+		    removeIframeListeners(iframe);
+		    if (destroyObserver) {
+		      destroyObserver.disconnect();
+		      destroyObserver = null;
+		    }
+		  }
+
+		  function getPagePosition(iframeId) {
+		    if (null === pagePosition) {
+		      pagePosition = {
+		        x:
+		          window.pageXOffset === undefined$1
+		            ? document.documentElement.scrollLeft
+		            : window.pageXOffset,
+		        y:
+		          window.pageYOffset === undefined$1
+		            ? document.documentElement.scrollTop
+		            : window.pageYOffset
+		      };
+		      log(
+		        iframeId,
+		        'Get page position: ' + pagePosition.x + ',' + pagePosition.y
+		      );
+		    }
+		  }
+
+		  function setPagePosition(iframeId) {
+		    if (null !== pagePosition) {
+		      window.scrollTo(pagePosition.x, pagePosition.y);
+		      log(
+		        iframeId,
+		        'Set page position: ' + pagePosition.x + ',' + pagePosition.y
+		      );
+		      unsetPagePosition();
+		    }
+		  }
+
+		  function unsetPagePosition() {
+		    pagePosition = null;
+		  }
+
+		  function resetIFrame(messageData) {
+		    function reset() {
+		      setSize(messageData);
+		      trigger('reset', 'reset', messageData.iframe, messageData.id);
+		    }
+
+		    log(
+		      messageData.id,
+		      'Size reset requested by ' +
+		        ('init' === messageData.type ? 'host page' : 'iFrame')
+		    );
+		    getPagePosition(messageData.id);
+		    syncResize(reset, messageData, 'reset');
+		  }
+
+		  function setSize(messageData) {
+		    function setDimension(dimension) {
+		      if (!messageData.id) {
+		        log('undefined', 'messageData id not set');
+		        return
+		      }
+		      messageData.iframe.style[dimension] = messageData[dimension] + 'px';
+		      log(
+		        messageData.id,
+		        'IFrame (' +
+		          iframeId +
+		          ') ' +
+		          dimension +
+		          ' set to ' +
+		          messageData[dimension] +
+		          'px'
+		      );
+		    }
+
+		    function chkZero(dimension) {
+		      // FireFox sets dimension of hidden iFrames to zero.
+		      // So if we detect that set up an event to check for
+		      // when iFrame becomes visible.
+
+		      /* istanbul ignore next */ // Not testable in PhantomJS
+		      if (!hiddenCheckEnabled && '0' === messageData[dimension]) {
+		        hiddenCheckEnabled = true;
+		        log(iframeId, 'Hidden iFrame detected, creating visibility listener');
+		        fixHiddenIFrames();
+		      }
+		    }
+
+		    function processDimension(dimension) {
+		      setDimension(dimension);
+		      chkZero(dimension);
+		    }
+
+		    var iframeId = messageData.iframe.id;
+
+		    if (settings[iframeId]) {
+		      if (settings[iframeId].sizeHeight) {
+		        processDimension('height');
+		      }
+		      if (settings[iframeId].sizeWidth) {
+		        processDimension('width');
+		      }
+		    }
+		  }
+
+		  function syncResize(func, messageData, doNotSync) {
+		    /* istanbul ignore if */ // Not testable in PhantomJS
+		    if (
+		      doNotSync !== messageData.type &&
+		      requestAnimationFrame &&
+		      // including check for jasmine because had trouble getting spy to work in unit test using requestAnimationFrame
+		      !window.jasmine
+		    ) {
+		      log(messageData.id, 'Requesting animation frame');
+		      requestAnimationFrame(func);
+		    } else {
+		      func();
+		    }
+		  }
+
+		  function trigger(calleeMsg, msg, iframe, id, noResponseWarning) {
+		    function postMessageToIFrame() {
+		      var target = settings[id] && settings[id].targetOrigin;
+		      log(
+		        id,
+		        '[' +
+		          calleeMsg +
+		          '] Sending msg to iframe[' +
+		          id +
+		          '] (' +
+		          msg +
+		          ') targetOrigin: ' +
+		          target
+		      );
+		      iframe.contentWindow.postMessage(msgId + msg, target);
+		    }
+
+		    function iFrameNotFound() {
+		      warn(id, '[' + calleeMsg + '] IFrame(' + id + ') not found');
+		    }
+
+		    function chkAndSend() {
+		      if (
+		        iframe &&
+		        'contentWindow' in iframe &&
+		        null !== iframe.contentWindow
+		      ) {
+		        // Null test for PhantomJS
+		        postMessageToIFrame();
+		      } else {
+		        iFrameNotFound();
+		      }
+		    }
+
+		    function warnOnNoResponse() {
+		      function warning() {
+		        if (settings[id] && !settings[id].loaded && !errorShown) {
+		          errorShown = true;
+		          warn(
+		            id,
+		            'IFrame has not responded within ' +
+		              settings[id].warningTimeout / 1000 +
+		              ' seconds. Check iFrameResizer.contentWindow.js has been loaded in iFrame. This message can be ignored if everything is working, or you can set the warningTimeout option to a higher value or zero to suppress this warning.'
+		          );
+		        }
+		      }
+
+		      if (
+		        !!noResponseWarning &&
+		        settings[id] &&
+		        !!settings[id].warningTimeout
+		      ) {
+		        settings[id].msgTimeout = setTimeout(
+		          warning,
+		          settings[id].warningTimeout
+		        );
+		      }
+		    }
+
+		    var errorShown = false;
+
+		    id = id || iframe.id;
+
+		    if (settings[id]) {
+		      chkAndSend();
+		      warnOnNoResponse();
+		    }
+		  }
+
+		  function createOutgoingMsg(iframeId) {
+		    return (
+		      iframeId +
+		      ':' +
+		      settings[iframeId].bodyMarginV1 +
+		      ':' +
+		      settings[iframeId].sizeWidth +
+		      ':' +
+		      settings[iframeId].log +
+		      ':' +
+		      settings[iframeId].interval +
+		      ':' +
+		      settings[iframeId].enablePublicMethods +
+		      ':' +
+		      settings[iframeId].autoResize +
+		      ':' +
+		      settings[iframeId].bodyMargin +
+		      ':' +
+		      settings[iframeId].heightCalculationMethod +
+		      ':' +
+		      settings[iframeId].bodyBackground +
+		      ':' +
+		      settings[iframeId].bodyPadding +
+		      ':' +
+		      settings[iframeId].tolerance +
+		      ':' +
+		      settings[iframeId].inPageLinks +
+		      ':' +
+		      settings[iframeId].resizeFrom +
+		      ':' +
+		      settings[iframeId].widthCalculationMethod +
+		      ':' +
+		      settings[iframeId].mouseEvents
+		    )
+		  }
+
+		  function isNumber(value) {
+		    return typeof value === 'number'
+		  }
+
+		  function setupIFrame(iframe, options) {
+		    function setLimits() {
+		      function addStyle(style) {
+		        var styleValue = settings[iframeId][style];
+		        if (Infinity !== styleValue && 0 !== styleValue) {
+		          iframe.style[style] = isNumber(styleValue)
+		            ? styleValue + 'px'
+		            : styleValue;
+		          log(iframeId, 'Set ' + style + ' = ' + iframe.style[style]);
+		        }
+		      }
+
+		      function chkMinMax(dimension) {
+		        if (
+		          settings[iframeId]['min' + dimension] >
+		          settings[iframeId]['max' + dimension]
+		        ) {
+		          throw new Error(
+		            'Value for min' +
+		              dimension +
+		              ' can not be greater than max' +
+		              dimension
+		          )
+		        }
+		      }
+
+		      chkMinMax('Height');
+		      chkMinMax('Width');
+
+		      addStyle('maxHeight');
+		      addStyle('minHeight');
+		      addStyle('maxWidth');
+		      addStyle('minWidth');
+		    }
+
+		    function newId() {
+		      var id = (options && options.id) || defaults.id + count++;
+		      if (null !== document.getElementById(id)) {
+		        id += count++;
+		      }
+		      return id
+		    }
+
+		    function ensureHasId(iframeId) {
+		      if (typeof iframeId !== 'string') {
+		        throw new TypeError('Invaild id for iFrame. Expected String')
+		      }
+
+		      if ('' === iframeId) {
+		        // eslint-disable-next-line no-multi-assign
+		        iframe.id = iframeId = newId();
+		        logEnabled = (options || {}).log;
+		        log(
+		          iframeId,
+		          'Added missing iframe ID: ' + iframeId + ' (' + iframe.src + ')'
+		        );
+		      }
+
+		      return iframeId
+		    }
+
+		    function setScrolling() {
+		      log(
+		        iframeId,
+		        'IFrame scrolling ' +
+		          (settings[iframeId] && settings[iframeId].scrolling
+		            ? 'enabled'
+		            : 'disabled') +
+		          ' for ' +
+		          iframeId
+		      );
+		      iframe.style.overflow =
+		        false === (settings[iframeId] && settings[iframeId].scrolling)
+		          ? 'hidden'
+		          : 'auto';
+		      switch (settings[iframeId] && settings[iframeId].scrolling) {
+		        case 'omit': {
+		          break
+		        }
+
+		        case true: {
+		          iframe.scrolling = 'yes';
+		          break
+		        }
+
+		        case false: {
+		          iframe.scrolling = 'no';
+		          break
+		        }
+
+		        default: {
+		          iframe.scrolling = settings[iframeId]
+		            ? settings[iframeId].scrolling
+		            : 'no';
+		        }
+		      }
+		    }
+
+		    // The V1 iFrame script expects an int, where as in V2 expects a CSS
+		    // string value such as '1px 3em', so if we have an int for V2, set V1=V2
+		    // and then convert V2 to a string PX value.
+		    function setupBodyMarginValues() {
+		      if (
+		        'number' ===
+		          typeof (settings[iframeId] && settings[iframeId].bodyMargin) ||
+		        '0' === (settings[iframeId] && settings[iframeId].bodyMargin)
+		      ) {
+		        settings[iframeId].bodyMarginV1 = settings[iframeId].bodyMargin;
+		        settings[iframeId].bodyMargin =
+		          '' + settings[iframeId].bodyMargin + 'px';
+		      }
+		    }
+
+		    function checkReset() {
+		      // Reduce scope of firstRun to function, because IE8's JS execution
+		      // context stack is borked and this value gets externally
+		      // changed midway through running this function!!!
+		      var firstRun = settings[iframeId] && settings[iframeId].firstRun,
+		        resetRequertMethod =
+		          settings[iframeId] &&
+		          settings[iframeId].heightCalculationMethod in resetRequiredMethods;
+
+		      if (!firstRun && resetRequertMethod) {
+		        resetIFrame({ iframe: iframe, height: 0, width: 0, type: 'init' });
+		      }
+		    }
+
+		    function setupIFrameObject() {
+		      if (settings[iframeId]) {
+		        settings[iframeId].iframe.iFrameResizer = {
+		          close: closeIFrame.bind(null, settings[iframeId].iframe),
+
+		          removeListeners: removeIframeListeners.bind(
+		            null,
+		            settings[iframeId].iframe
+		          ),
+
+		          resize: trigger.bind(
+		            null,
+		            'Window resize',
+		            'resize',
+		            settings[iframeId].iframe
+		          ),
+
+		          moveToAnchor: function (anchor) {
+		            trigger(
+		              'Move to anchor',
+		              'moveToAnchor:' + anchor,
+		              settings[iframeId].iframe,
+		              iframeId
+		            );
+		          },
+
+		          sendMessage: function (message) {
+		            message = JSON.stringify(message);
+		            trigger(
+		              'Send Message',
+		              'message:' + message,
+		              settings[iframeId].iframe,
+		              iframeId
+		            );
+		          }
+		        };
+		      }
+		    }
+
+		    // We have to call trigger twice, as we can not be sure if all
+		    // iframes have completed loading when this code runs. The
+		    // event listener also catches the page changing in the iFrame.
+		    function init(msg) {
+		      function iFrameLoaded() {
+		        trigger('iFrame.onload', msg, iframe, undefined$1, true);
+		        checkReset();
+		      }
+
+		      function createDestroyObserver(MutationObserver) {
+		        if (!iframe.parentNode) {
+		          return null
+		        }
+
+		        var destroyObserver = new MutationObserver(function (mutations) {
+		          mutations.forEach(function (mutation) {
+		            var removedNodes = Array.prototype.slice.call(mutation.removedNodes); // Transform NodeList into an Array
+		            removedNodes.forEach(function (removedNode) {
+		              if (removedNode === iframe) {
+		                closeIFrame(iframe);
+		              }
+		            });
+		          });
+		        });
+		        destroyObserver.observe(iframe.parentNode, {
+		          childList: true
+		        });
+		        return destroyObserver
+		      }
+
+		      var MutationObserver = getMutationObserver();
+		      if (MutationObserver) {
+		        destroyObserver = createDestroyObserver(MutationObserver);
+		      }
+
+		      addEventListener(iframe, 'load', iFrameLoaded);
+		      trigger('init', msg, iframe, undefined$1, true);
+		    }
+
+		    function checkOptions(options) {
+		      if ('object' !== typeof options) {
+		        throw new TypeError('Options is not an object')
+		      }
+		    }
+
+		    function copyOptions(options) {
+		      // eslint-disable-next-line no-restricted-syntax
+		      for (var option in defaults) {
+		        if (Object.prototype.hasOwnProperty.call(defaults, option)) {
+		          settings[iframeId][option] = Object.prototype.hasOwnProperty.call(
+		            options,
+		            option
+		          )
+		            ? options[option]
+		            : defaults[option];
+		        }
+		      }
+		    }
+
+		    function getTargetOrigin(remoteHost) {
+		      return '' === remoteHost ||
+		        null !== remoteHost.match(/^(about:blank|javascript:|file:\/\/)/)
+		        ? '*'
+		        : remoteHost
+		    }
+
+		    function depricate(key) {
+		      var splitName = key.split('Callback');
+
+		      if (splitName.length === 2) {
+		        var name =
+		          'on' + splitName[0].charAt(0).toUpperCase() + splitName[0].slice(1);
+		        this[name] = this[key];
+		        delete this[key];
+		        warn(
+		          iframeId,
+		          "Deprecated: '" +
+		            key +
+		            "' has been renamed '" +
+		            name +
+		            "'. The old method will be removed in the next major version."
+		        );
+		      }
+		    }
+
+		    function processOptions(options) {
+		      options = options || {};
+
+		      settings[iframeId] = Object.create(null); // Protect against prototype attacks
+		      settings[iframeId].iframe = iframe;
+		      settings[iframeId].firstRun = true;
+		      settings[iframeId].remoteHost =
+		        iframe.src && iframe.src.split('/').slice(0, 3).join('/');
+
+		      checkOptions(options);
+		      Object.keys(options).forEach(depricate, options);
+		      copyOptions(options);
+
+		      if (settings[iframeId]) {
+		        settings[iframeId].targetOrigin =
+		          true === settings[iframeId].checkOrigin
+		            ? getTargetOrigin(settings[iframeId].remoteHost)
+		            : '*';
+		      }
+		    }
+
+		    function beenHere() {
+		      return iframeId in settings && 'iFrameResizer' in iframe
+		    }
+
+		    var iframeId = ensureHasId(iframe.id);
+
+		    if (beenHere()) {
+		      warn(iframeId, 'Ignored iFrame, already setup.');
+		    } else {
+		      processOptions(options);
+		      setScrolling();
+		      setLimits();
+		      setupBodyMarginValues();
+		      init(createOutgoingMsg(iframeId));
+		      setupIFrameObject();
+		    }
+		  }
+
+		  function debouce(fn, time) {
+		    if (null === timer) {
+		      timer = setTimeout(function () {
+		        timer = null;
+		        fn();
+		      }, time);
+		    }
+		  }
+
+		  var frameTimer = {};
+		  function debounceFrameEvents(fn, time, frameId) {
+		    if (!frameTimer[frameId]) {
+		      frameTimer[frameId] = setTimeout(function () {
+		        frameTimer[frameId] = null;
+		        fn();
+		      }, time);
+		    }
+		  }
+
+		  // Not testable in PhantomJS
+		  /* istanbul ignore next */
+
+		  function fixHiddenIFrames() {
+		    function checkIFrames() {
+		      function checkIFrame(settingId) {
+		        function chkDimension(dimension) {
+		          return (
+		            '0px' ===
+		            (settings[settingId] && settings[settingId].iframe.style[dimension])
+		          )
+		        }
+
+		        function isVisible(el) {
+		          return null !== el.offsetParent
+		        }
+
+		        if (
+		          settings[settingId] &&
+		          isVisible(settings[settingId].iframe) &&
+		          (chkDimension('height') || chkDimension('width'))
+		        ) {
+		          trigger(
+		            'Visibility change',
+		            'resize',
+		            settings[settingId].iframe,
+		            settingId
+		          );
+		        }
+		      }
+
+		      Object.keys(settings).forEach(function (key) {
+		        checkIFrame(key);
+		      });
+		    }
+
+		    function mutationObserved(mutations) {
+		      log(
+		        'window',
+		        'Mutation observed: ' + mutations[0].target + ' ' + mutations[0].type
+		      );
+		      debouce(checkIFrames, 16);
+		    }
+
+		    function createMutationObserver() {
+		      var target = document.querySelector('body'),
+		        config = {
+		          attributes: true,
+		          attributeOldValue: false,
+		          characterData: true,
+		          characterDataOldValue: false,
+		          childList: true,
+		          subtree: true
+		        },
+		        observer = new MutationObserver(mutationObserved);
+
+		      observer.observe(target, config);
+		    }
+
+		    var MutationObserver = getMutationObserver();
+		    if (MutationObserver) {
+		      createMutationObserver();
+		    }
+		  }
+
+		  function resizeIFrames(event) {
+		    function resize() {
+		      sendTriggerMsg('Window ' + event, 'resize');
+		    }
+
+		    log('window', 'Trigger event: ' + event);
+		    debouce(resize, 16);
+		  }
+
+		  // Not testable in PhantomJS
+		  /* istanbul ignore next */
+		  function tabVisible() {
+		    function resize() {
+		      sendTriggerMsg('Tab Visible', 'resize');
+		    }
+
+		    if ('hidden' !== document.visibilityState) {
+		      log('document', 'Trigger event: Visibility change');
+		      debouce(resize, 16);
+		    }
+		  }
+
+		  function sendTriggerMsg(eventName, event) {
+		    function isIFrameResizeEnabled(iframeId) {
+		      return (
+		        settings[iframeId] &&
+		        'parent' === settings[iframeId].resizeFrom &&
+		        settings[iframeId].autoResize &&
+		        !settings[iframeId].firstRun
+		      )
+		    }
+
+		    Object.keys(settings).forEach(function (iframeId) {
+		      if (isIFrameResizeEnabled(iframeId)) {
+		        trigger(eventName, event, settings[iframeId].iframe, iframeId);
+		      }
+		    });
+		  }
+
+		  function setupEventListeners() {
+		    addEventListener(window, 'message', iFrameListener);
+
+		    addEventListener(window, 'resize', function () {
+		      resizeIFrames('resize');
+		    });
+
+		    addEventListener(document, 'visibilitychange', tabVisible);
+
+		    addEventListener(document, '-webkit-visibilitychange', tabVisible);
+		  }
+
+		  function factory() {
+		    function init(options, element) {
+		      function chkType() {
+		        if (!element.tagName) {
+		          throw new TypeError('Object is not a valid DOM element')
+		        } else if ('IFRAME' !== element.tagName.toUpperCase()) {
+		          throw new TypeError(
+		            'Expected <IFRAME> tag, found <' + element.tagName + '>'
+		          )
+		        }
+		      }
+
+		      if (element) {
+		        chkType();
+		        setupIFrame(element, options);
+		        iFrames.push(element);
+		      }
+		    }
+
+		    function warnDeprecatedOptions(options) {
+		      if (options && options.enablePublicMethods) {
+		        warn(
+		          'enablePublicMethods option has been removed, public methods are now always available in the iFrame'
+		        );
+		      }
+		    }
+
+		    var iFrames;
+
+		    setupRequestAnimationFrame();
+		    setupEventListeners();
+
+		    return function iFrameResizeF(options, target) {
+		      iFrames = []; // Only return iFrames past in on this call
+
+		      warnDeprecatedOptions(options);
+
+		      switch (typeof target) {
+		        case 'undefined':
+		        case 'string': {
+		          Array.prototype.forEach.call(
+		            document.querySelectorAll(target || 'iframe'),
+		            init.bind(undefined$1, options)
+		          );
+		          break
+		        }
+
+		        case 'object': {
+		          init(options, target);
+		          break
+		        }
+
+		        default: {
+		          throw new TypeError('Unexpected data type (' + typeof target + ')')
+		        }
+		      }
+
+		      return iFrames
+		    }
+		  }
+
+		  function createJQueryPublicMethod($) {
+		    if (!$.fn) {
+		      info('', 'Unable to bind to jQuery, it is not fully loaded.');
+		    } else if (!$.fn.iFrameResize) {
+		      $.fn.iFrameResize = function $iFrameResizeF(options) {
+		        function init(index, element) {
+		          setupIFrame(element, options);
+		        }
+
+		        return this.filter('iframe').each(init).end()
+		      };
+		    }
+		  }
+
+		  if (window.jQuery !== undefined$1) {
+		    createJQueryPublicMethod(window.jQuery);
+		  }
+
+		  {
+		    // Node for browserfy
+		    module.exports = factory();
+		  }
+		  window.iFrameResize = window.iFrameResize || factory();
+		})(); 
+	} (iframeResizer$1));
+	return iframeResizer$1.exports;
+}
+
+var iframeResizer_contentWindow = {exports: {}};
+
+/*
+ * File: iframeResizer.contentWindow.js
+ * Desc: Include this file in any page being loaded into an iframe
+ *       to force the iframe to resize to the content size.
+ * Requires: iframeResizer.js on host page.
+ * Doc: https://iframe-resizer.com
+ * Author: David J. Bradshaw - info@iframe-resizer.com
+ *
+ */
+
+var hasRequiredIframeResizer_contentWindow;
+
+function requireIframeResizer_contentWindow () {
+	if (hasRequiredIframeResizer_contentWindow) return iframeResizer_contentWindow.exports;
+	hasRequiredIframeResizer_contentWindow = 1;
+	(function (module) {
+(function (undefined$1) {
+		  if (typeof window === 'undefined') return // don't run for server side render
+
+		  var autoResize = true,
+		    base = 10,
+		    bodyBackground = '',
+		    bodyMargin = 0,
+		    bodyMarginStr = '',
+		    bodyObserver = null,
+		    bodyPadding = '',
+		    calculateWidth = false,
+		    doubleEventList = { resize: 1, click: 1 },
+		    eventCancelTimer = 128,
+		    firstRun = true,
+		    height = 1,
+		    heightCalcModeDefault = 'bodyOffset',
+		    heightCalcMode = heightCalcModeDefault,
+		    initLock = true,
+		    initMsg = '',
+		    inPageLinks = {},
+		    interval = 32,
+		    intervalTimer = null,
+		    logging = false,
+		    mouseEvents = false,
+		    msgID = '[iFrameSizer]', // Must match host page msg ID
+		    msgIdLen = msgID.length,
+		    myID = '',
+		    resetRequiredMethods = {
+		      max: 1,
+		      min: 1,
+		      bodyScroll: 1,
+		      documentElementScroll: 1
+		    },
+		    resizeFrom = 'child',
+		    target = window.parent,
+		    targetOriginDefault = '*',
+		    tolerance = 0,
+		    triggerLocked = false,
+		    triggerLockedTimer = null,
+		    throttledTimer = 16,
+		    width = 1,
+		    widthCalcModeDefault = 'scroll',
+		    widthCalcMode = widthCalcModeDefault,
+		    win = window,
+		    onMessage = function () {
+		      warn('onMessage function not defined');
+		    },
+		    onReady = function () {},
+		    onPageInfo = function () {},
+		    customCalcMethods = {
+		      height: function () {
+		        warn('Custom height calculation function not defined');
+		        return document.documentElement.offsetHeight
+		      },
+		      width: function () {
+		        warn('Custom width calculation function not defined');
+		        return document.body.scrollWidth
+		      }
+		    },
+		    eventHandlersByName = {},
+		    passiveSupported = false;
+
+		  function noop() {}
+
+		  try {
+		    var options = Object.create(
+		      {},
+		      {
+		        passive: {
+		          // eslint-disable-next-line getter-return
+		          get: function () {
+		            passiveSupported = true;
+		          }
+		        }
+		      }
+		    );
+		    window.addEventListener('test', noop, options);
+		    window.removeEventListener('test', noop, options);
+		  } catch (error) {
+		    /* */
+		  }
+
+		  function addEventListener(el, evt, func, options) {
+		    el.addEventListener(evt, func, passiveSupported ? options || {} : false);
+		  }
+
+		  function removeEventListener(el, evt, func) {
+		    el.removeEventListener(evt, func, false);
+		  }
+
+		  function capitalizeFirstLetter(string) {
+		    return string.charAt(0).toUpperCase() + string.slice(1)
+		  }
+
+		  // Based on underscore.js
+		  function throttle(func) {
+		    var context,
+		      args,
+		      result,
+		      timeout = null,
+		      previous = 0,
+		      later = function () {
+		        previous = Date.now();
+		        timeout = null;
+		        result = func.apply(context, args);
+		        if (!timeout) {
+		          // eslint-disable-next-line no-multi-assign
+		          context = args = null;
+		        }
+		      };
+
+		    return function () {
+		      var now = Date.now();
+
+		      if (!previous) {
+		        previous = now;
+		      }
+
+		      var remaining = throttledTimer - (now - previous);
+
+		      context = this;
+		      args = arguments;
+
+		      if (remaining <= 0 || remaining > throttledTimer) {
+		        if (timeout) {
+		          clearTimeout(timeout);
+		          timeout = null;
+		        }
+
+		        previous = now;
+		        result = func.apply(context, args);
+
+		        if (!timeout) {
+		          // eslint-disable-next-line no-multi-assign
+		          context = args = null;
+		        }
+		      } else if (!timeout) {
+		        timeout = setTimeout(later, remaining);
+		      }
+
+		      return result
+		    }
+		  }
+
+		  function formatLogMsg(msg) {
+		    return msgID + '[' + myID + '] ' + msg
+		  }
+
+		  function log(msg) {
+		    if (logging && 'object' === typeof window.console) {
+		      // eslint-disable-next-line no-console
+		      console.log(formatLogMsg(msg));
+		    }
+		  }
+
+		  function warn(msg) {
+		    if ('object' === typeof window.console) {
+		      // eslint-disable-next-line no-console
+		      console.warn(formatLogMsg(msg));
+		    }
+		  }
+
+		  function init() {
+		    readDataFromParent();
+		    log('Initialising iFrame (' + window.location.href + ')');
+		    readDataFromPage();
+		    setMargin();
+		    setBodyStyle('background', bodyBackground);
+		    setBodyStyle('padding', bodyPadding);
+		    injectClearFixIntoBodyElement();
+		    checkHeightMode();
+		    checkWidthMode();
+		    stopInfiniteResizingOfIFrame();
+		    setupPublicMethods();
+		    setupMouseEvents();
+		    startEventListeners();
+		    inPageLinks = setupInPageLinks();
+		    sendSize('init', 'Init message from host page');
+		    onReady();
+		  }
+
+		  function readDataFromParent() {
+		    function strBool(str) {
+		      return 'true' === str
+		    }
+
+		    var data = initMsg.slice(msgIdLen).split(':');
+
+		    myID = data[0];
+		    bodyMargin = undefined$1 === data[1] ? bodyMargin : Number(data[1]); // For V1 compatibility
+		    calculateWidth = undefined$1 === data[2] ? calculateWidth : strBool(data[2]);
+		    logging = undefined$1 === data[3] ? logging : strBool(data[3]);
+		    interval = undefined$1 === data[4] ? interval : Number(data[4]);
+		    autoResize = undefined$1 === data[6] ? autoResize : strBool(data[6]);
+		    bodyMarginStr = data[7];
+		    heightCalcMode = undefined$1 === data[8] ? heightCalcMode : data[8];
+		    bodyBackground = data[9];
+		    bodyPadding = data[10];
+		    tolerance = undefined$1 === data[11] ? tolerance : Number(data[11]);
+		    inPageLinks.enable = undefined$1 === data[12] ? false : strBool(data[12]);
+		    resizeFrom = undefined$1 === data[13] ? resizeFrom : data[13];
+		    widthCalcMode = undefined$1 === data[14] ? widthCalcMode : data[14];
+		    mouseEvents = undefined$1 === data[15] ? mouseEvents : strBool(data[15]);
+		  }
+
+		  function depricate(key) {
+		    var splitName = key.split('Callback');
+
+		    if (splitName.length === 2) {
+		      var name =
+		        'on' + splitName[0].charAt(0).toUpperCase() + splitName[0].slice(1);
+		      this[name] = this[key];
+		      delete this[key];
+		      warn(
+		        "Deprecated: '" +
+		          key +
+		          "' has been renamed '" +
+		          name +
+		          "'. The old method will be removed in the next major version."
+		      );
+		    }
+		  }
+
+		  function readDataFromPage() {
+		    function readData() {
+		      var data = window.iFrameResizer;
+
+		      log('Reading data from page: ' + JSON.stringify(data));
+		      Object.keys(data).forEach(depricate, data);
+
+		      onMessage = 'onMessage' in data ? data.onMessage : onMessage;
+		      onReady = 'onReady' in data ? data.onReady : onReady;
+		      targetOriginDefault =
+		        'targetOrigin' in data ? data.targetOrigin : targetOriginDefault;
+		      heightCalcMode =
+		        'heightCalculationMethod' in data
+		          ? data.heightCalculationMethod
+		          : heightCalcMode;
+		      widthCalcMode =
+		        'widthCalculationMethod' in data
+		          ? data.widthCalculationMethod
+		          : widthCalcMode;
+		    }
+
+		    function setupCustomCalcMethods(calcMode, calcFunc) {
+		      if ('function' === typeof calcMode) {
+		        log('Setup custom ' + calcFunc + 'CalcMethod');
+		        customCalcMethods[calcFunc] = calcMode;
+		        calcMode = 'custom';
+		      }
+
+		      return calcMode
+		    }
+
+		    if (
+		      'iFrameResizer' in window &&
+		      Object === window.iFrameResizer.constructor
+		    ) {
+		      readData();
+		      heightCalcMode = setupCustomCalcMethods(heightCalcMode, 'height');
+		      widthCalcMode = setupCustomCalcMethods(widthCalcMode, 'width');
+		    }
+
+		    log('TargetOrigin for parent set to: ' + targetOriginDefault);
+		  }
+
+		  function chkCSS(attr, value) {
+		    if (-1 !== value.indexOf('-')) {
+		      warn('Negative CSS value ignored for ' + attr);
+		      value = '';
+		    }
+		    return value
+		  }
+
+		  function setBodyStyle(attr, value) {
+		    if (undefined$1 !== value && '' !== value && 'null' !== value) {
+		      document.body.style[attr] = value;
+		      log('Body ' + attr + ' set to "' + value + '"');
+		    }
+		  }
+
+		  function setMargin() {
+		    // If called via V1 script, convert bodyMargin from int to str
+		    if (undefined$1 === bodyMarginStr) {
+		      bodyMarginStr = bodyMargin + 'px';
+		    }
+
+		    setBodyStyle('margin', chkCSS('margin', bodyMarginStr));
+		  }
+
+		  function stopInfiniteResizingOfIFrame() {
+		    document.documentElement.style.height = '';
+		    document.body.style.height = '';
+		    log('HTML & body height set to "auto"');
+		  }
+
+		  function manageTriggerEvent(options) {
+		    var listener = {
+		      add: function (eventName) {
+		        function handleEvent() {
+		          sendSize(options.eventName, options.eventType);
+		        }
+
+		        eventHandlersByName[eventName] = handleEvent;
+
+		        addEventListener(window, eventName, handleEvent, { passive: true });
+		      },
+		      remove: function (eventName) {
+		        var handleEvent = eventHandlersByName[eventName];
+		        delete eventHandlersByName[eventName];
+
+		        removeEventListener(window, eventName, handleEvent);
+		      }
+		    };
+
+		    if (options.eventNames && Array.prototype.map) {
+		      options.eventName = options.eventNames[0];
+		      options.eventNames.map(listener[options.method]);
+		    } else {
+		      listener[options.method](options.eventName);
+		    }
+
+		    log(
+		      capitalizeFirstLetter(options.method) +
+		        ' event listener: ' +
+		        options.eventType
+		    );
+		  }
+
+		  function manageEventListeners(method) {
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Animation Start',
+		      eventNames: ['animationstart', 'webkitAnimationStart']
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Animation Iteration',
+		      eventNames: ['animationiteration', 'webkitAnimationIteration']
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Animation End',
+		      eventNames: ['animationend', 'webkitAnimationEnd']
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Input',
+		      eventName: 'input'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Mouse Up',
+		      eventName: 'mouseup'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Mouse Down',
+		      eventName: 'mousedown'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Orientation Change',
+		      eventName: 'orientationchange'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Print',
+		      eventNames: ['afterprint', 'beforeprint']
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Ready State Change',
+		      eventName: 'readystatechange'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Touch Start',
+		      eventName: 'touchstart'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Touch End',
+		      eventName: 'touchend'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Touch Cancel',
+		      eventName: 'touchcancel'
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Transition Start',
+		      eventNames: [
+		        'transitionstart',
+		        'webkitTransitionStart',
+		        'MSTransitionStart',
+		        'oTransitionStart',
+		        'otransitionstart'
+		      ]
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Transition Iteration',
+		      eventNames: [
+		        'transitioniteration',
+		        'webkitTransitionIteration',
+		        'MSTransitionIteration',
+		        'oTransitionIteration',
+		        'otransitioniteration'
+		      ]
+		    });
+		    manageTriggerEvent({
+		      method: method,
+		      eventType: 'Transition End',
+		      eventNames: [
+		        'transitionend',
+		        'webkitTransitionEnd',
+		        'MSTransitionEnd',
+		        'oTransitionEnd',
+		        'otransitionend'
+		      ]
+		    });
+		    if ('child' === resizeFrom) {
+		      manageTriggerEvent({
+		        method: method,
+		        eventType: 'IFrame Resized',
+		        eventName: 'resize'
+		      });
+		    }
+		  }
+
+		  function checkCalcMode(calcMode, calcModeDefault, modes, type) {
+		    if (calcModeDefault !== calcMode) {
+		      if (!(calcMode in modes)) {
+		        warn(
+		          calcMode + ' is not a valid option for ' + type + 'CalculationMethod.'
+		        );
+		        calcMode = calcModeDefault;
+		      }
+		      log(type + ' calculation method set to "' + calcMode + '"');
+		    }
+
+		    return calcMode
+		  }
+
+		  function checkHeightMode() {
+		    heightCalcMode = checkCalcMode(
+		      heightCalcMode,
+		      heightCalcModeDefault,
+		      getHeight,
+		      'height'
+		    );
+		  }
+
+		  function checkWidthMode() {
+		    widthCalcMode = checkCalcMode(
+		      widthCalcMode,
+		      widthCalcModeDefault,
+		      getWidth,
+		      'width'
+		    );
+		  }
+
+		  function startEventListeners() {
+		    if (true === autoResize) {
+		      manageEventListeners('add');
+		      setupMutationObserver();
+		    } else {
+		      log('Auto Resize disabled');
+		    }
+		  }
+
+		  //   function stopMsgsToParent() {
+		  //     log('Disable outgoing messages')
+		  //     sendPermit = false
+		  //   }
+
+		  //   function removeMsgListener() {
+		  //     log('Remove event listener: Message')
+		  //     removeEventListener(window, 'message', receiver)
+		  //   }
+
+		  function disconnectMutationObserver() {
+		    if (null !== bodyObserver) {
+		      /* istanbul ignore next */ // Not testable in PhantonJS
+		      bodyObserver.disconnect();
+		    }
+		  }
+
+		  function stopEventListeners() {
+		    manageEventListeners('remove');
+		    disconnectMutationObserver();
+		    clearInterval(intervalTimer);
+		  }
+
+		  //   function teardown() {
+		  //     stopMsgsToParent()
+		  //     removeMsgListener()
+		  //     if (true === autoResize) stopEventListeners()
+		  //   }
+
+		  function injectClearFixIntoBodyElement() {
+		    var clearFix = document.createElement('div');
+		    clearFix.style.clear = 'both';
+		    // Guard against the following having been globally redefined in CSS.
+		    clearFix.style.display = 'block';
+		    clearFix.style.height = '0';
+		    document.body.appendChild(clearFix);
+		  }
+
+		  function setupInPageLinks() {
+		    function getPagePosition() {
+		      return {
+		        x:
+		          window.pageXOffset === undefined$1
+		            ? document.documentElement.scrollLeft
+		            : window.pageXOffset,
+		        y:
+		          window.pageYOffset === undefined$1
+		            ? document.documentElement.scrollTop
+		            : window.pageYOffset
+		      }
+		    }
+
+		    function getElementPosition(el) {
+		      var elPosition = el.getBoundingClientRect(),
+		        pagePosition = getPagePosition();
+
+		      return {
+		        x: parseInt(elPosition.left, 10) + parseInt(pagePosition.x, 10),
+		        y: parseInt(elPosition.top, 10) + parseInt(pagePosition.y, 10)
+		      }
+		    }
+
+		    function findTarget(location) {
+		      function jumpToTarget(target) {
+		        var jumpPosition = getElementPosition(target);
+
+		        log(
+		          'Moving to in page link (#' +
+		            hash +
+		            ') at x: ' +
+		            jumpPosition.x +
+		            ' y: ' +
+		            jumpPosition.y
+		        );
+		        sendMsg(jumpPosition.y, jumpPosition.x, 'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+		      }
+
+		      var hash = location.split('#')[1] || location, // Remove # if present
+		        hashData = decodeURIComponent(hash),
+		        target =
+		          document.getElementById(hashData) ||
+		          document.getElementsByName(hashData)[0];
+
+		      if (undefined$1 === target) {
+		        log(
+		          'In page link (#' +
+		            hash +
+		            ') not found in iFrame, so sending to parent'
+		        );
+		        sendMsg(0, 0, 'inPageLink', '#' + hash);
+		      } else {
+		        jumpToTarget(target);
+		      }
+		    }
+
+		    function checkLocationHash() {
+		      var hash = window.location.hash;
+		      var href = window.location.href;
+
+		      if ('' !== hash && '#' !== hash) {
+		        findTarget(href);
+		      }
+		    }
+
+		    function bindAnchors() {
+		      function setupLink(el) {
+		        function linkClicked(e) {
+		          e.preventDefault();
+
+		          /* jshint validthis:true */
+		          findTarget(this.getAttribute('href'));
+		        }
+
+		        if ('#' !== el.getAttribute('href')) {
+		          addEventListener(el, 'click', linkClicked);
+		        }
+		      }
+
+		      Array.prototype.forEach.call(
+		        document.querySelectorAll('a[href^="#"]'),
+		        setupLink
+		      );
+		    }
+
+		    function bindLocationHash() {
+		      addEventListener(window, 'hashchange', checkLocationHash);
+		    }
+
+		    function initCheck() {
+		      // Check if page loaded with location hash after init resize
+		      setTimeout(checkLocationHash, eventCancelTimer);
+		    }
+
+		    function enableInPageLinks() {
+		      /* istanbul ignore else */ // Not testable in phantonJS
+		      if (Array.prototype.forEach && document.querySelectorAll) {
+		        log('Setting up location.hash handlers');
+		        bindAnchors();
+		        bindLocationHash();
+		        initCheck();
+		      } else {
+		        warn(
+		          'In page linking not fully supported in this browser! (See README.md for IE8 workaround)'
+		        );
+		      }
+		    }
+
+		    if (inPageLinks.enable) {
+		      enableInPageLinks();
+		    } else {
+		      log('In page linking not enabled');
+		    }
+
+		    return {
+		      findTarget: findTarget
+		    }
+		  }
+
+		  function setupMouseEvents() {
+		    if (mouseEvents !== true) return
+
+		    function sendMouse(e) {
+		      sendMsg(0, 0, e.type, e.screenY + ':' + e.screenX);
+		    }
+
+		    function addMouseListener(evt, name) {
+		      log('Add event listener: ' + name);
+		      addEventListener(window.document, evt, sendMouse);
+		    }
+
+		    addMouseListener('mouseenter', 'Mouse Enter');
+		    addMouseListener('mouseleave', 'Mouse Leave');
+		  }
+
+		  function setupPublicMethods() {
+		    log('Enable public methods');
+
+		    win.parentIFrame = {
+		      autoResize: function autoResizeF(resize) {
+		        if (true === resize && false === autoResize) {
+		          autoResize = true;
+		          startEventListeners();
+		        } else if (false === resize && true === autoResize) {
+		          autoResize = false;
+		          stopEventListeners();
+		        }
+		        sendMsg(0, 0, 'autoResize', JSON.stringify(autoResize));
+		        return autoResize
+		      },
+
+		      close: function closeF() {
+		        sendMsg(0, 0, 'close');
+		        // teardown()
+		      },
+
+		      getId: function getIdF() {
+		        return myID
+		      },
+
+		      getPageInfo: function getPageInfoF(callback) {
+		        if ('function' === typeof callback) {
+		          onPageInfo = callback;
+		          sendMsg(0, 0, 'pageInfo');
+		        } else {
+		          onPageInfo = function () {};
+		          sendMsg(0, 0, 'pageInfoStop');
+		        }
+		      },
+
+		      moveToAnchor: function moveToAnchorF(hash) {
+		        inPageLinks.findTarget(hash);
+		      },
+
+		      reset: function resetF() {
+		        resetIFrame('parentIFrame.reset');
+		      },
+
+		      scrollTo: function scrollToF(x, y) {
+		        sendMsg(y, x, 'scrollTo'); // X&Y reversed at sendMsg uses height/width
+		      },
+
+		      scrollToOffset: function scrollToF(x, y) {
+		        sendMsg(y, x, 'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+		      },
+
+		      sendMessage: function sendMessageF(msg, targetOrigin) {
+		        sendMsg(0, 0, 'message', JSON.stringify(msg), targetOrigin);
+		      },
+
+		      setHeightCalculationMethod: function setHeightCalculationMethodF(
+		        heightCalculationMethod
+		      ) {
+		        heightCalcMode = heightCalculationMethod;
+		        checkHeightMode();
+		      },
+
+		      setWidthCalculationMethod: function setWidthCalculationMethodF(
+		        widthCalculationMethod
+		      ) {
+		        widthCalcMode = widthCalculationMethod;
+		        checkWidthMode();
+		      },
+
+		      setTargetOrigin: function setTargetOriginF(targetOrigin) {
+		        log('Set targetOrigin: ' + targetOrigin);
+		        targetOriginDefault = targetOrigin;
+		      },
+
+		      size: function sizeF(customHeight, customWidth) {
+		        var valString =
+		          '' + (customHeight || '') + (customWidth ? ',' + customWidth : '');
+		        sendSize(
+		          'size',
+		          'parentIFrame.size(' + valString + ')',
+		          customHeight,
+		          customWidth
+		        );
+		      }
+		    };
+		  }
+
+		  function initInterval() {
+		    if (0 !== interval) {
+		      log('setInterval: ' + interval + 'ms');
+		      intervalTimer = setInterval(function () {
+		        sendSize('interval', 'setInterval: ' + interval);
+		      }, Math.abs(interval));
+		    }
+		  }
+
+		  // Not testable in PhantomJS
+		  /* istanbul ignore next */
+		  function setupBodyMutationObserver() {
+		    function addImageLoadListners(mutation) {
+		      function addImageLoadListener(element) {
+		        if (false === element.complete) {
+		          log('Attach listeners to ' + element.src);
+		          element.addEventListener('load', imageLoaded, false);
+		          element.addEventListener('error', imageError, false);
+		          elements.push(element);
+		        }
+		      }
+
+		      if (mutation.type === 'attributes' && mutation.attributeName === 'src') {
+		        addImageLoadListener(mutation.target);
+		      } else if (mutation.type === 'childList') {
+		        Array.prototype.forEach.call(
+		          mutation.target.querySelectorAll('img'),
+		          addImageLoadListener
+		        );
+		      }
+		    }
+
+		    function removeFromArray(element) {
+		      elements.splice(elements.indexOf(element), 1);
+		    }
+
+		    function removeImageLoadListener(element) {
+		      log('Remove listeners from ' + element.src);
+		      element.removeEventListener('load', imageLoaded, false);
+		      element.removeEventListener('error', imageError, false);
+		      removeFromArray(element);
+		    }
+
+		    function imageEventTriggered(event, type, typeDesc) {
+		      removeImageLoadListener(event.target);
+		      sendSize(type, typeDesc + ': ' + event.target.src);
+		    }
+
+		    function imageLoaded(event) {
+		      imageEventTriggered(event, 'imageLoad', 'Image loaded');
+		    }
+
+		    function imageError(event) {
+		      imageEventTriggered(event, 'imageLoadFailed', 'Image load failed');
+		    }
+
+		    function mutationObserved(mutations) {
+		      sendSize(
+		        'mutationObserver',
+		        'mutationObserver: ' + mutations[0].target + ' ' + mutations[0].type
+		      );
+
+		      // Deal with WebKit / Blink asyncing image loading when tags are injected into the page
+		      mutations.forEach(addImageLoadListners);
+		    }
+
+		    function createMutationObserver() {
+		      var target = document.querySelector('body'),
+		        config = {
+		          attributes: true,
+		          attributeOldValue: false,
+		          characterData: true,
+		          characterDataOldValue: false,
+		          childList: true,
+		          subtree: true
+		        };
+
+		      observer = new MutationObserver(mutationObserved);
+
+		      log('Create body MutationObserver');
+		      observer.observe(target, config);
+
+		      return observer
+		    }
+
+		    var elements = [],
+		      MutationObserver =
+		        window.MutationObserver || window.WebKitMutationObserver,
+		      observer = createMutationObserver();
+
+		    return {
+		      disconnect: function () {
+		        if ('disconnect' in observer) {
+		          log('Disconnect body MutationObserver');
+		          observer.disconnect();
+		          elements.forEach(removeImageLoadListener);
+		        }
+		      }
+		    }
+		  }
+
+		  function setupMutationObserver() {
+		    var forceIntervalTimer = 0 > interval;
+
+		    // Not testable in PhantomJS
+		    /* istanbul ignore if */ if (
+		      window.MutationObserver ||
+		      window.WebKitMutationObserver
+		    ) {
+		      if (forceIntervalTimer) {
+		        initInterval();
+		      } else {
+		        bodyObserver = setupBodyMutationObserver();
+		      }
+		    } else {
+		      log('MutationObserver not supported in this browser!');
+		      initInterval();
+		    }
+		  }
+
+		  // document.documentElement.offsetHeight is not reliable, so
+		  // we have to jump through hoops to get a better value.
+		  function getComputedStyle(prop, el) {
+		    var retVal = 0;
+		    el = el || document.body; // Not testable in phantonJS
+
+		    retVal = document.defaultView.getComputedStyle(el, null);
+		    retVal = null === retVal ? 0 : retVal[prop];
+
+		    return parseInt(retVal, base)
+		  }
+
+		  function chkEventThottle(timer) {
+		    if (timer > throttledTimer / 2) {
+		      throttledTimer = 2 * timer;
+		      log('Event throttle increased to ' + throttledTimer + 'ms');
+		    }
+		  }
+
+		  // Idea from https://github.com/guardian/iframe-messenger
+		  function getMaxElement(side, elements) {
+		    var elementsLength = elements.length,
+		      elVal = 0,
+		      maxVal = 0,
+		      Side = capitalizeFirstLetter(side),
+		      timer = Date.now();
+
+		    for (var i = 0; i < elementsLength; i++) {
+		      elVal =
+		        elements[i].getBoundingClientRect()[side] +
+		        getComputedStyle('margin' + Side, elements[i]);
+		      if (elVal > maxVal) {
+		        maxVal = elVal;
+		      }
+		    }
+
+		    timer = Date.now() - timer;
+
+		    log('Parsed ' + elementsLength + ' HTML elements');
+		    log('Element position calculated in ' + timer + 'ms');
+
+		    chkEventThottle(timer);
+
+		    return maxVal
+		  }
+
+		  function getAllMeasurements(dimensions) {
+		    return [
+		      dimensions.bodyOffset(),
+		      dimensions.bodyScroll(),
+		      dimensions.documentElementOffset(),
+		      dimensions.documentElementScroll()
+		    ]
+		  }
+
+		  function getTaggedElements(side, tag) {
+		    function noTaggedElementsFound() {
+		      warn('No tagged elements (' + tag + ') found on page');
+		      return document.querySelectorAll('body *')
+		    }
+
+		    var elements = document.querySelectorAll('[' + tag + ']');
+
+		    if (elements.length === 0) noTaggedElementsFound();
+
+		    return getMaxElement(side, elements)
+		  }
+
+		  function getAllElements() {
+		    return document.querySelectorAll('body *')
+		  }
+
+		  var getHeight = {
+		      bodyOffset: function getBodyOffsetHeight() {
+		        return (
+		          document.body.offsetHeight +
+		          getComputedStyle('marginTop') +
+		          getComputedStyle('marginBottom')
+		        )
+		      },
+
+		      offset: function () {
+		        return getHeight.bodyOffset() // Backwards compatibility
+		      },
+
+		      bodyScroll: function getBodyScrollHeight() {
+		        return document.body.scrollHeight
+		      },
+
+		      custom: function getCustomWidth() {
+		        return customCalcMethods.height()
+		      },
+
+		      documentElementOffset: function getDEOffsetHeight() {
+		        return document.documentElement.offsetHeight
+		      },
+
+		      documentElementScroll: function getDEScrollHeight() {
+		        return document.documentElement.scrollHeight
+		      },
+
+		      max: function getMaxHeight() {
+		        return Math.max.apply(null, getAllMeasurements(getHeight))
+		      },
+
+		      min: function getMinHeight() {
+		        return Math.min.apply(null, getAllMeasurements(getHeight))
+		      },
+
+		      grow: function growHeight() {
+		        return getHeight.max() // Run max without the forced downsizing
+		      },
+
+		      lowestElement: function getBestHeight() {
+		        return Math.max(
+		          getHeight.bodyOffset() || getHeight.documentElementOffset(),
+		          getMaxElement('bottom', getAllElements())
+		        )
+		      },
+
+		      taggedElement: function getTaggedElementsHeight() {
+		        return getTaggedElements('bottom', 'data-iframe-height')
+		      }
+		    },
+		    getWidth = {
+		      bodyScroll: function getBodyScrollWidth() {
+		        return document.body.scrollWidth
+		      },
+
+		      bodyOffset: function getBodyOffsetWidth() {
+		        return document.body.offsetWidth
+		      },
+
+		      custom: function getCustomWidth() {
+		        return customCalcMethods.width()
+		      },
+
+		      documentElementScroll: function getDEScrollWidth() {
+		        return document.documentElement.scrollWidth
+		      },
+
+		      documentElementOffset: function getDEOffsetWidth() {
+		        return document.documentElement.offsetWidth
+		      },
+
+		      scroll: function getMaxWidth() {
+		        return Math.max(getWidth.bodyScroll(), getWidth.documentElementScroll())
+		      },
+
+		      max: function getMaxWidth() {
+		        return Math.max.apply(null, getAllMeasurements(getWidth))
+		      },
+
+		      min: function getMinWidth() {
+		        return Math.min.apply(null, getAllMeasurements(getWidth))
+		      },
+
+		      rightMostElement: function rightMostElement() {
+		        return getMaxElement('right', getAllElements())
+		      },
+
+		      taggedElement: function getTaggedElementsWidth() {
+		        return getTaggedElements('right', 'data-iframe-width')
+		      }
+		    };
+
+		  function sizeIFrame(
+		    triggerEvent,
+		    triggerEventDesc,
+		    customHeight,
+		    customWidth
+		  ) {
+		    function resizeIFrame() {
+		      height = currentHeight;
+		      width = currentWidth;
+
+		      sendMsg(height, width, triggerEvent);
+		    }
+
+		    function isSizeChangeDetected() {
+		      function checkTolarance(a, b) {
+		        var retVal = Math.abs(a - b) <= tolerance;
+		        return !retVal
+		      }
+
+		      currentHeight =
+		        undefined$1 === customHeight ? getHeight[heightCalcMode]() : customHeight;
+		      currentWidth =
+		        undefined$1 === customWidth ? getWidth[widthCalcMode]() : customWidth;
+
+		      return (
+		        checkTolarance(height, currentHeight) ||
+		        (calculateWidth && checkTolarance(width, currentWidth))
+		      )
+		    }
+
+		    function isForceResizableEvent() {
+		      return !(triggerEvent in { init: 1, interval: 1, size: 1 })
+		    }
+
+		    function isForceResizableCalcMode() {
+		      return (
+		        heightCalcMode in resetRequiredMethods ||
+		        (calculateWidth && widthCalcMode in resetRequiredMethods)
+		      )
+		    }
+
+		    function logIgnored() {
+		      log('No change in size detected');
+		    }
+
+		    function checkDownSizing() {
+		      if (isForceResizableEvent() && isForceResizableCalcMode()) {
+		        resetIFrame(triggerEventDesc);
+		      } else if (!(triggerEvent in { interval: 1 })) {
+		        logIgnored();
+		      }
+		    }
+
+		    var currentHeight, currentWidth;
+
+		    if (isSizeChangeDetected() || 'init' === triggerEvent) {
+		      lockTrigger();
+		      resizeIFrame();
+		    } else {
+		      checkDownSizing();
+		    }
+		  }
+
+		  var sizeIFrameThrottled = throttle(sizeIFrame);
+
+		  function sendSize(triggerEvent, triggerEventDesc, customHeight, customWidth) {
+		    function recordTrigger() {
+		      if (!(triggerEvent in { reset: 1, resetPage: 1, init: 1 })) {
+		        log('Trigger event: ' + triggerEventDesc);
+		      }
+		    }
+
+		    function isDoubleFiredEvent() {
+		      return triggerLocked && triggerEvent in doubleEventList
+		    }
+
+		    if (isDoubleFiredEvent()) {
+		      log('Trigger event cancelled: ' + triggerEvent);
+		    } else {
+		      recordTrigger();
+		      if (triggerEvent === 'init') {
+		        sizeIFrame(triggerEvent, triggerEventDesc, customHeight, customWidth);
+		      } else {
+		        sizeIFrameThrottled(
+		          triggerEvent,
+		          triggerEventDesc,
+		          customHeight,
+		          customWidth
+		        );
+		      }
+		    }
+		  }
+
+		  function lockTrigger() {
+		    if (!triggerLocked) {
+		      triggerLocked = true;
+		      log('Trigger event lock on');
+		    }
+		    clearTimeout(triggerLockedTimer);
+		    triggerLockedTimer = setTimeout(function () {
+		      triggerLocked = false;
+		      log('Trigger event lock off');
+		      log('--');
+		    }, eventCancelTimer);
+		  }
+
+		  function triggerReset(triggerEvent) {
+		    height = getHeight[heightCalcMode]();
+		    width = getWidth[widthCalcMode]();
+
+		    sendMsg(height, width, triggerEvent);
+		  }
+
+		  function resetIFrame(triggerEventDesc) {
+		    var hcm = heightCalcMode;
+		    heightCalcMode = heightCalcModeDefault;
+
+		    log('Reset trigger event: ' + triggerEventDesc);
+		    lockTrigger();
+		    triggerReset('reset');
+
+		    heightCalcMode = hcm;
+		  }
+
+		  function sendMsg(height, width, triggerEvent, msg, targetOrigin) {
+		    function setTargetOrigin() {
+		      if (undefined$1 === targetOrigin) {
+		        targetOrigin = targetOriginDefault;
+		      } else {
+		        log('Message targetOrigin: ' + targetOrigin);
+		      }
+		    }
+
+		    function sendToParent() {
+		      var size = height + ':' + width,
+		        message =
+		          myID +
+		          ':' +
+		          size +
+		          ':' +
+		          triggerEvent +
+		          (undefined$1 === msg ? '' : ':' + msg);
+
+		      log('Sending message to host page (' + message + ')');
+		      target.postMessage(msgID + message, targetOrigin);
+		    }
+
+		    {
+		      setTargetOrigin();
+		      sendToParent();
+		    }
+		  }
+
+		  function receiver(event) {
+		    var processRequestFromParent = {
+		      init: function initFromParent() {
+		        initMsg = event.data;
+		        target = event.source;
+
+		        init();
+		        firstRun = false;
+		        setTimeout(function () {
+		          initLock = false;
+		        }, eventCancelTimer);
+		      },
+
+		      reset: function resetFromParent() {
+		        if (initLock) {
+		          log('Page reset ignored by init');
+		        } else {
+		          log('Page size reset by host page');
+		          triggerReset('resetPage');
+		        }
+		      },
+
+		      resize: function resizeFromParent() {
+		        sendSize('resizeParent', 'Parent window requested size check');
+		      },
+
+		      moveToAnchor: function moveToAnchorF() {
+		        inPageLinks.findTarget(getData());
+		      },
+		      inPageLink: function inPageLinkF() {
+		        this.moveToAnchor();
+		      }, // Backward compatibility
+
+		      pageInfo: function pageInfoFromParent() {
+		        var msgBody = getData();
+		        log('PageInfoFromParent called from parent: ' + msgBody);
+		        onPageInfo(JSON.parse(msgBody));
+		        log(' --');
+		      },
+
+		      message: function messageFromParent() {
+		        var msgBody = getData();
+
+		        log('onMessage called from parent: ' + msgBody);
+		        // eslint-disable-next-line sonarjs/no-extra-arguments
+		        onMessage(JSON.parse(msgBody));
+		        log(' --');
+		      }
+		    };
+
+		    function isMessageForUs() {
+		      return msgID === ('' + event.data).slice(0, msgIdLen) // ''+ Protects against non-string messages
+		    }
+
+		    function getMessageType() {
+		      return event.data.split(']')[1].split(':')[0]
+		    }
+
+		    function getData() {
+		      return event.data.slice(event.data.indexOf(':') + 1)
+		    }
+
+		    function isMiddleTier() {
+		      return (
+		        (!(module.exports) &&
+		          'iFrameResize' in window) ||
+		        (window.jQuery !== undefined$1 &&
+		          'iFrameResize' in window.jQuery.prototype)
+		      )
+		    }
+
+		    function isInitMsg() {
+		      // Test if this message is from a child below us. This is an ugly test, however, updating
+		      // the message format would break backwards compatibility.
+		      return event.data.split(':')[2] in { true: 1, false: 1 }
+		    }
+
+		    function callFromParent() {
+		      var messageType = getMessageType();
+
+		      if (messageType in processRequestFromParent) {
+		        processRequestFromParent[messageType]();
+		      } else if (!isMiddleTier() && !isInitMsg()) {
+		        warn('Unexpected message (' + event.data + ')');
+		      }
+		    }
+
+		    function processMessage() {
+		      if (false === firstRun) {
+		        callFromParent();
+		      } else if (isInitMsg()) {
+		        processRequestFromParent.init();
+		      } else {
+		        log(
+		          'Ignored message of type "' +
+		            getMessageType() +
+		            '". Received before initialization.'
+		        );
+		      }
+		    }
+
+		    if (isMessageForUs()) {
+		      processMessage();
+		    }
+		  }
+
+		  // Normally the parent kicks things off when it detects the iFrame has loaded.
+		  // If this script is async-loaded, then tell parent page to retry init.
+		  function chkLateLoaded() {
+		    if ('loading' !== document.readyState) {
+		      window.parent.postMessage('[iFrameResizerChild]Ready', '*');
+		    }
+		  }
+
+		  // Setup if not already running
+		  if (!('iframeResizer' in window)) {
+		    window.iframeChildListener = function (data) {
+		      receiver({ data});
+		    };
+		    addEventListener(window, 'message', receiver);
+		    addEventListener(window, 'readystatechange', chkLateLoaded);
+		    chkLateLoaded();
+		  }
+
+		  
+		})(); 
+	} (iframeResizer_contentWindow));
+	return iframeResizer_contentWindow.exports;
+}
+
+var iframeResizer;
+var hasRequiredIframeResizer;
+
+function requireIframeResizer () {
+	if (hasRequiredIframeResizer) return iframeResizer;
+	hasRequiredIframeResizer = 1;
+	const iframeResize = requireIframeResizer$1();
+
+	iframeResizer = {
+	  iframeResize: iframeResize,
+	  iframeResizer: iframeResize, // Backwards compatibility
+	  contentWindow: requireIframeResizer_contentWindow()
+	};
+	return iframeResizer;
+}
+
+var iframeResizerExports = requireIframeResizer();
+var iFrameResizeModule = /*@__PURE__*/getDefaultExportFromCjs(iframeResizerExports);
+
+const stzhIframeCss = () => `.sc-stzh-iframe-h{font-family:var(--stzh-font-family-medium);font-weight:var(--stzh-font-weight-medium);font-style:var(--stzh-font-style-medium);color:var(--stzh-base-color);box-sizing:border-box;display:block}[hidden].sc-stzh-iframe-h,[stzh-hidden].sc-stzh-iframe-h{display:none}.sc-stzh-iframe-h::selection{color:var(--stzh-selection-color);background-color:var(--stzh-selection-background-color)}.sc-stzh-iframe-h *.sc-stzh-iframe,.sc-stzh-iframe-h *.sc-stzh-iframe::before,.sc-stzh-iframe-h *.sc-stzh-iframe::after{box-sizing:border-box;text-underline-offset:var(--stzh-link-text-underline-offset);text-decoration-thickness:var(--stzh-link-text-decoration-thickness);-webkit-text-decoration-skip-ink:var(--stzh-link-text-decoration-skip-ink);text-decoration-skip-ink:var(--stzh-link-text-decoration-skip-ink)}.sc-stzh-iframe-h .has-focus.sc-stzh-iframe{outline:var(--stzh-flyingfocus-color) solid 0.125rem;outline-offset:0.125rem}.sc-stzh-iframe-h .stzh-fylingfocus-focused.sc-stzh-iframe{outline-style:none !important}.sc-stzh-iframe-h .stzh-fylingfocus-focused.sc-stzh-iframe::-moz-focus-inner{border:0 !important}.sc-stzh-iframe-h{position:relative}.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=preview-logo],.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=preview-logo]{width:100%}.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=preview-image],.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=preview-image]{position:absolute;top:0;left:0;width:100%;height:100%;object-fit:cover}.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text]{margin:0}.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p,.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text] p{margin:0}.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p,.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child),.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child){margin-bottom:var(--stzh-space-xsmall)}@media screen and (min-width: 600px){.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p,.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child),.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child){margin-bottom:var(--stzh-space-small)}}@media screen and (min-width: 900px){.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p,.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child),.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child){margin-bottom:var(--stzh-space-medium)}}@media screen and (min-width: 1260px){.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text],.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p,.sc-stzh-iframe-h.sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child),.sc-stzh-iframe-h .sc-stzh-iframe-s>[slot=cookiewall-text] p:not(:last-child){margin-bottom:var(--stzh-space-xlarge)}}.stzh-iframe.sc-stzh-iframe{width:100%;height:100%}.stzh-iframe__iframe.sc-stzh-iframe{width:100%}.stzh-iframe__cookiewall.sc-stzh-iframe,.stzh-iframe__preview.sc-stzh-iframe{position:absolute;top:0;left:0;width:100%;height:100%}.stzh-iframe__iframe.sc-stzh-iframe,.stzh-iframe__preview.sc-stzh-iframe{border:none}.stzh-iframe__preview.sc-stzh-iframe,.stzh-iframe__cookiewall.sc-stzh-iframe{display:flex;flex-direction:column;align-items:center;justify-content:center;padding:var(--stzh-space-medium);visibility:hidden}.stzh-iframe__preview.is-visible.sc-stzh-iframe,.stzh-iframe__cookiewall.is-visible.sc-stzh-iframe{visibility:visible}.stzh-iframe__preview.sc-stzh-iframe{z-index:1;appearance:none;cursor:pointer;background-color:var(--stzh-color-grey20)}.stzh-iframe__preview-image-wrapper.sc-stzh-iframe:not(:empty)+.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{display:none}.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{top:var(--stzh-space-large)}@media screen and (min-width: 600px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{top:var(--stzh-space-xlarge)}}@media screen and (min-width: 900px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{top:var(--stzh-space-xxlarge)}}@media screen and (min-width: 1260px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{top:var(--stzh-space-xxxlarge)}}.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{left:var(--stzh-space-large)}@media screen and (min-width: 600px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{left:var(--stzh-space-xlarge)}}@media screen and (min-width: 900px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{left:var(--stzh-space-xxlarge)}}@media screen and (min-width: 1260px){.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{left:var(--stzh-space-xxxlarge)}}.stzh-iframe__preview-logo-wrapper.sc-stzh-iframe{position:absolute;width:45%}.stzh-iframe__preview-run.sc-stzh-iframe{position:relative;z-index:1;appearance:none;border:none;background-color:var(--stzh-color-primary);color:var(--stzh-color-white);display:flex;flex-direction:column;align-items:center;justify-content:center;width:var(--stzh-form-input-small-height);height:var(--stzh-form-input-small-height);visibility:hidden;transition:background-color var(--stzh-base-transition-animation-speed)}.stzh-iframe__preview-run.is-visible.sc-stzh-iframe{visibility:visible}@media screen and (min-width: 900px){.stzh-iframe__preview-run.sc-stzh-iframe{width:var(--stzh-form-input-height);height:var(--stzh-form-input-height)}}.stzh-iframe__preview.sc-stzh-iframe:hover .stzh-iframe__preview-run.sc-stzh-iframe{background-color:var(--stzh-color-secondary60)}@media screen and (min-width: 900px){.stzh-iframe__preview-run-icon.sc-stzh-iframe{--size:var(--stzh-icon-size-large)}}.stzh-iframe__cookiewall.sc-stzh-iframe{padding-left:var(--stzh-space-medium)}@media screen and (min-width: 600px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-left:var(--stzh-space-large)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-left:var(--stzh-space-xlarge)}}@media screen and (min-width: 1260px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-left:var(--stzh-space-xxlarge)}}.stzh-iframe__cookiewall.sc-stzh-iframe{padding-right:var(--stzh-space-medium)}@media screen and (min-width: 600px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-right:var(--stzh-space-large)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-right:var(--stzh-space-xlarge)}}@media screen and (min-width: 1260px){.stzh-iframe__cookiewall.sc-stzh-iframe{padding-right:var(--stzh-space-xxlarge)}}.stzh-iframe__cookiewall.sc-stzh-iframe{z-index:2;text-align:center;background-color:var(--stzh-color-black60op);color:var(--stzh-color-white)}@media screen and (min-width: 900px){.stzh-iframe__cookiewall.sc-stzh-iframe{column-gap:var(--stzh-grid-gutter);display:grid;grid-template-areas:". content content content content content content .";grid-template-columns:repeat(8, minmax(0, 1fr));padding-left:0;padding-right:0}}@media screen and (min-width: 900px) and (min-width: 600px){.stzh-iframe__cookiewall.sc-stzh-iframe{column-gap:var(--stzh-grid-gutter-small)}}@media screen and (min-width: 900px) and (min-width: 900px){.stzh-iframe__cookiewall.sc-stzh-iframe{column-gap:var(--stzh-grid-gutter-medium)}}@media screen and (min-width: 900px) and (min-width: 1260px){.stzh-iframe__cookiewall.sc-stzh-iframe{column-gap:var(--stzh-grid-gutter-large)}}@media screen and (min-width: 900px) and (min-width: 1600px){.stzh-iframe__cookiewall.sc-stzh-iframe{column-gap:var(--stzh-grid-gutter-ultra)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall-content.sc-stzh-iframe{grid-area:content}}.stzh-iframe__cookiewall-text.sc-stzh-iframe{font-size:var(--stzh-font-milli-font-size);line-height:var(--stzh-font-milli-text-line-height);letter-spacing:var(--stzh-font-curve---text-letter-spacing);padding-top:var(--stzh-space-xsmall)}@media screen and (min-width: 600px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-top:var(--stzh-space-small)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-top:var(--stzh-space-medium)}}@media screen and (min-width: 1260px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-top:var(--stzh-space-xlarge)}}.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-bottom:var(--stzh-space-xsmall)}@media screen and (min-width: 600px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-bottom:var(--stzh-space-small)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-bottom:var(--stzh-space-medium)}}@media screen and (min-width: 1260px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{padding-bottom:var(--stzh-space-xlarge)}}.stzh-iframe__cookiewall-text.sc-stzh-iframe{margin-bottom:var(--stzh-space-medium)}@media screen and (min-width: 600px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{margin-bottom:var(--stzh-space-large)}}@media screen and (min-width: 900px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{margin-bottom:var(--stzh-space-xlarge)}}@media screen and (min-width: 1260px){.stzh-iframe__cookiewall-text.sc-stzh-iframe{margin-bottom:var(--stzh-space-xxlarge)}}.stzh-iframe__cookiewall-close.sc-stzh-iframe{top:0;right:0;position:absolute;appearance:none;border:none;display:flex;align-items:center;justify-content:center;padding:var(--stzh-space-xsmall);background-color:transparent;color:var(--stzh-color-white);cursor:pointer}`;
+
+// Save the original console.log method
+const originalConsoleLog = console.log;
+// Override console.log to suppress messages
+console.log = function () { };
+// this import was only used in the resize function line 169, leaving here for the reviewer to decide if it can be deleted for good.
+// import { getStzhEnvironment, StzhEnvironmentEnum } from "../../utils/utils";
+console.log = originalConsoleLog;
+const COOKIE_PREFIX_CONFIRM = "stzh-components-iframe-confirm";
+let iframeCounter = 0;
+const StzhIframe = /*@__PURE__*/ proxyCustomElement(class StzhIframe extends H {
+    constructor(registerHost) {
+        super();
+        if (registerHost !== false) {
+            this.__registerHost();
+        }
+        this.stzhPreviewSkip = createEvent(this, "stzhPreviewSkip");
+        this.stzhViewChange = createEvent(this, "stzhViewChange");
+        /** Automatic height resizing of iFrame (Option SameSecondLevelDomain is Deprecated)*/
+        this.iframeResizerVariant = "None";
+        /**
+         * Allow of Iframe
+         * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe?retiredLocale=de#allow
+         */
+        this.allow = "autoplay; fullscreen";
+        /** Width of iframe */
+        this.width = "100%";
+        /** Width of iframe */
+        this.height = "100%";
+        /** `src` of iframe */
+        this.src = "";
+        this._src = null;
+        /**
+         * Number of days the cookie is valid for.
+         * If omitted or set to null, the cookie expires when browser is closed.
+         * Maximum is on year (365 days, is default).
+         */
+        this.cookieExpires = 365;
+        /** Preview icon */
+        this.previewIcon = "external-link";
+        /** Whether preview should be skipped, if user has passed the cookiewall before */
+        this.skipPreviewIfCookieAccepted = false;
+        /** Whether preview should always be skipped */
+        this.skipPreview = false;
+        this.view = "preview";
+        this.updateFocus = false;
+        this.handleIframeLoad = () => {
+            if (this.updateFocus) {
+                this.iframeElement.focus();
+                this.updateFocus = false;
+            }
+            this.initializeIframeResizing();
+        };
+        this.handleCookiewallCloseClick = () => {
+            this.updateFocus = true;
+            this.view = "preview";
+            this.stzhViewChange.emit({
+                component: "stzh-iframe",
+                value: this.view,
+            });
+        };
+        this.handleCookiewallConfirmClick = () => {
+            api.set(`${COOKIE_PREFIX_CONFIRM}-${this.cookie}`, "1", {
+                expires: this.cookieExpires || null,
+            });
+            this.updateFocus = true;
+            this.view = "iframe";
+            this.stzhViewChange.emit({
+                component: "stzh-iframe",
+                value: this.view,
+            });
+        };
+        this.handlePreviewClick = () => {
+            const cookieAccepted = api.get(`${COOKIE_PREFIX_CONFIRM}-${this.cookie}`) || false;
+            this.updateFocus = true;
+            if (!this.cookie || cookieAccepted) {
+                this.view = "iframe";
+            }
+            else {
+                this.view = "cookiewall";
+            }
+            this.stzhViewChange.emit({
+                component: "stzh-iframe",
+                value: this.view,
+            });
+        };
+    }
+    srcWatcher(newValue) {
+        if (this.view === "iframe") {
+            this._src = newValue;
+        }
+    }
+    viewWatcher(newValue) {
+        if (newValue === "iframe") {
+            this._src = this.src;
+        }
+        else {
+            this._src = null;
+        }
+    }
+    initializeIframeResizing() {
+        switch (this.iframeResizerVariant) {
+            case "None":
+                return;
+            case "PostMessage":
+                iFrameResizeModule.iframeResize({
+                    log: false, // getStzhEnvironment() !== StzhEnvironmentEnum.PROD,
+                    checkOrigin: false,
+                }, this.iframeElement);
+                break;
+            case "SameSecondLevelDomain":
+                console.warn("stzh-iframe: sameSecondLevelDomain is deprecated as it does no longer work on evergreen browsers, use PostMessage instead.");
+                if (!this.iframeResizerSecondlevelDomain) {
+                    console.log("stzh-iframe:", "property 'iframeSecondlevelDomain' not filled out.");
+                }
+                this.setupIframeAutoSizing({
+                    frameId: this.iframeId,
+                    heightCorrection: this.iframeResizerHeightCorrection || 0,
+                    hasSameDomain: false,
+                    secondLevelDomain: this.iframeResizerSecondlevelDomain,
+                });
+                break;
+        }
+    }
+    setupIframeAutoSizing(config) {
+        const createResizer = (iframe, config) => {
+            return () => {
+                var _a;
+                try {
+                    const newHeight = ((_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.document.body.scrollHeight) || 0;
+                    if (newHeight > 0) {
+                        iframe.style.height = `${newHeight + config.heightCorrection}px`;
+                    }
+                }
+                catch (error) {
+                    console.warn("stzh-iframe:", "Resizing not possible, perhaps due to cross-domain restrictions:", error);
+                }
+            };
+        };
+        if (!config.hasSameDomain) {
+            document.domain = config.secondLevelDomain;
+        }
+        const iframe = document.getElementById(config.frameId);
+        if (!iframe) {
+            console.error(`Iframe with ID ${config.frameId} not found`);
+            return;
+        }
+        const resizer = createResizer(iframe, config);
+        window.addEventListener("resize", resizer);
+        iframe.addEventListener("load", resizer);
+        iframe.addEventListener("blur", resizer);
+        iframe.addEventListener("readystatechange", resizer); // hack for internet explorer...
+        try {
+            // this might go wrong on IE, if iframe hasn't fully loaded yet, but it doesn't matter.
+            resizer();
+        }
+        catch (error) {
+            console.warn("Initial resize failed, likely due to iframe not being fully loaded yet:", error);
+        }
+    }
+    async componentWillLoad() {
+        this.internalId = `stzh-iframe-${iframeCounter++}`;
+        const cookieAccepted = api.get(`${COOKIE_PREFIX_CONFIRM}-${this.cookie}`) || false;
+        if (((!this.cookie || cookieAccepted) && (this.skipPreviewIfCookieAccepted || this.skipPreview)) ||
+            (!this.cookie && this.skipPreview)) {
+            this.stzhPreviewSkip.emit({
+                component: "stzh-iframe",
+            });
+            this.view = "iframe";
+        }
+        else if (this.cookie && this.skipPreview) {
+            this.view = "cookiewall";
+        }
+        this.viewWatcher(this.view);
+        if (!this.localization) {
+            this.localization = await window.stzhComponents.utils.fetchTranslations(this.element, "iframe");
+        }
+    }
+    async componentDidRender() {
+        if (this.updateFocus) {
+            if (this.view === "iframe") ;
+            else if (this.view === "preview") {
+                this.previewButtonElement.focus();
+                this.updateFocus = false;
+            }
+            else if (this.view === "cookiewall") {
+                this.confirmButtonElement.focus();
+                this.updateFocus = false;
+            }
+        }
+    }
+    render() {
+        const classes = {
+            "stzh-iframe": true,
+        };
+        return (h(Host, { key: '1fe69c3ed66fcf2df93b326c561a6028440692f8' }, h("div", { key: '82c58641c4db576f6294f8393a986b943e772037', class: classes }, this.view === "iframe" && (h("iframe", { key: '034edfb3de8526aecade255a12d0bea73c9d7c71', id: this.iframeId, name: this.name, sandbox: this.sandbox, referrerPolicy: this.referrerpolicy, width: this.width, height: this.height, ref: el => (this.iframeElement = el), class: "stzh-iframe__iframe", src: this._src, allow: this.allow, onLoad: this.handleIframeLoad }, this.iframeErrorText)), h("button", { key: '241e3cf41fc8937e6552fbb11b9639f2bae81deb', ref: el => (this.previewButtonElement = el), onClick: this.handlePreviewClick, "aria-label": this.previewLabel || this.localization.defaultPreviewLabel,
+            // disabled={this.view === "cookiewall"}
+            class: {
+                "stzh-iframe__preview": true,
+                "is-visible": this.view === "preview" || this.view === "cookiewall",
+            } }, h("div", { key: '59b04f8ea93e8c235d9bba0957d3a63e12a2c095', class: "stzh-iframe__preview-image-wrapper" }, h("slot", { key: 'ebc653577a767530f95f67cf0ba6bcf0dc051e9a', name: "preview-image" })), h("div", { key: 'b1777308ade82ccbd82c870b8e15ceee41124e44', class: "stzh-iframe__preview-logo-wrapper" }, h("slot", { key: '3fe5a67d48484ffecb7e59c46bdeb608130959fc', name: "preview-logo" })), this.previewIcon && (h("div", { key: 'ad2566078d6d368c3c4d3a32ffe6fb8ce3a47f4c', class: {
+                "stzh-iframe__preview-run": true,
+                "is-visible": this.view === "preview",
+            } }, h("stzh-icon", { key: 'f7229a598f04da50096adc3c88d4bef42d9e9e12', class: "stzh-iframe__preview-run-icon", name: this.previewIcon })))), this.cookie && (h("div", { key: '0c7901bee220013d19dd97b64c32df893bf5c5f1', class: {
+                "stzh-iframe__cookiewall": true,
+                "is-visible": this.view === "cookiewall",
+            } }, h("div", { key: 'f4376e70c26584881df1a3258e4cd5a9da7c65c0', class: "stzh-iframe__cookiewall-content" }, h("div", { key: 'dae5a42169876ae0e176afbcc0d2f86a9f426667', class: "stzh-iframe__cookiewall-text", id: `${this.internalId}-cookiewall-text` }, this.cookieConfirmText ? this.cookieConfirmText : h("slot", { name: "cookiewall-text" })), h("stzh-button", { key: '3557ea0293bc76e09a944c46f09b59ee606cef02', ref: el => (this.confirmButtonElement = el), class: "stzh-iframe__cookiewall-button", size: "small", a11yDescribedby: `${this.internalId}-cookiewall-text`, icon: this.cookieConfirmIcon, label: this.cookieConfirmLabel || this.localization.defaultConfirmLabel, onClick: this.handleCookiewallConfirmClick })), !this.skipPreview && (h("button", { key: '0bc9209657a7e522ffcb263b179504197750cd31', class: "stzh-iframe__cookiewall-close", onClick: this.handleCookiewallCloseClick, "aria-label": this.localization.confirmCloseLabel }, h("stzh-icon", { key: '3de9e76a87abfde642139fc941da28aee0f1d98f', class: "stzh-iframe__cookiewall-close-icon", name: "close" }))))))));
+    }
+    get element() { return this; }
+    static get watchers() { return {
+        "src": ["srcWatcher"],
+        "view": ["viewWatcher"]
+    }; }
+    static get style() { return stzhIframeCss(); }
+}, [262, "stzh-iframe", {
+        "localization": [16],
+        "iframeId": [1, "iframe-id"],
+        "iframeErrorText": [1, "iframe-error-text"],
+        "iframeResizerVariant": [1, "iframe-resizer-variant"],
+        "iframeResizerHeightCorrection": [2, "iframe-resizer-height-correction"],
+        "iframeResizerSecondlevelDomain": [1, "iframe-resizer-secondlevel-domain"],
+        "name": [1],
+        "sandbox": [1],
+        "referrerpolicy": [1],
+        "allow": [1],
+        "width": [1],
+        "height": [1],
+        "src": [1],
+        "cookie": [1],
+        "cookieExpires": [2, "cookie-expires"],
+        "cookieConfirmIcon": [1, "cookie-confirm-icon"],
+        "cookieConfirmLabel": [1, "cookie-confirm-label"],
+        "cookieConfirmText": [1, "cookie-confirm-text"],
+        "previewLabel": [1, "preview-label"],
+        "previewIcon": [1, "preview-icon"],
+        "skipPreviewIfCookieAccepted": [4, "skip-preview-if-cookie-accepted"],
+        "skipPreview": [4, "skip-preview"],
+        "view": [32]
+    }, undefined, {
+        "src": ["srcWatcher"],
+        "view": ["viewWatcher"]
+    }]);
+function defineCustomElement() {
+    if (typeof customElements === "undefined") {
+        return;
+    }
+    const components = ["stzh-iframe", "stzh-badge", "stzh-button", "stzh-icon"];
+    components.forEach(tagName => { switch (tagName) {
+        case "stzh-iframe":
+            if (!customElements.get(transformTag(tagName))) {
+                customElements.define(transformTag(tagName), StzhIframe);
+            }
+            break;
+        case "stzh-badge":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$3();
+            }
+            break;
+        case "stzh-button":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$2();
+            }
+            break;
+        case "stzh-icon":
+            if (!customElements.get(transformTag(tagName))) {
+                defineCustomElement$1();
+            }
+            break;
+    } });
+}
+
+export { StzhIframe as S, defineCustomElement as d };
+//# sourceMappingURL=p-CF0Eco5y.js.map
+
+//# sourceMappingURL=p-CF0Eco5y.js.map