/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ "./src/beaver/index.js"
/*!*****************************!*\
  !*** ./src/beaver/index.js ***!
  \*****************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _style_css__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./style.css */ "./src/beaver/style.css");
/* harmony import */ var _shared_share_bar_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../shared/share-bar.css */ "./src/shared/share-bar.css");
/* harmony import */ var _shared_publish_guard_ui__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../shared/publish-guard-ui */ "./src/shared/publish-guard-ui.js");



(function bootBeaverReview(attempt) {
  const drawer = document.getElementById('flow-ew-beaver-drawer');
  const toggle = document.getElementById('flow-ew-beaver-toggle');
  if (!drawer || !toggle) {
    if (attempt < 150) {
      requestAnimationFrame(function () {
        bootBeaverReview(attempt + 1);
      });
    }
    return;
  }
  if (drawer.dataset.flowEwBeaverReady === '1') {
    return;
  }
  drawer.dataset.flowEwBeaverReady = '1';
  function getDrawer() {
    return document.getElementById('flow-ew-beaver-drawer');
  }
  function isBeaverDarkSkin() {
    return document.body.classList.contains('fl-builder-ui-skin--dark');
  }
  function syncBeaverDarkSkin() {
    const panel = getDrawer();
    if (!panel) {
      return;
    }
    const classic = panel.querySelector('.flow-ew-classic--beaver');
    if (classic) {
      classic.classList.toggle('flow-ew-classic--builder-dark', isBeaverDarkSkin());
    }
  }
  syncBeaverDarkSkin();
  if (!document.body.dataset.flowEwBeaverSkinObserver) {
    document.body.dataset.flowEwBeaverSkinObserver = '1';
    const skinObserver = new MutationObserver(syncBeaverDarkSkin);
    skinObserver.observe(document.body, {
      attributes: true,
      attributeFilter: ['class']
    });
  }
  function resolveToggle() {
    return document.getElementById('flow-ew-beaver-toggle');
  }
  function resolveToolbarProxy() {
    return document.querySelector('.flow-ew-beaver-toggle-proxy');
  }
  function resolvePanelArrow() {
    const panel = getDrawer();
    return panel ? panel.querySelector('.fl-builder--panel-arrow') : null;
  }
  function isDrawerOpen() {
    const panel = getDrawer();
    return !!panel && panel.classList.contains('is-open');
  }
  function isToggleInteraction(target) {
    if (!target || !target.closest) {
      return false;
    }
    return !!target.closest('.flow-ew-beaver-toggle-proxy');
  }
  function hideBeaverContentPanel() {
    if (window.FLBuilder && typeof window.FLBuilder.triggerHook === 'function') {
      window.FLBuilder.triggerHook('hideContentPanel');
    }
  }
  function replayPanelAnimation(panel) {
    if (!panel) {
      return;
    }
    panel.style.animation = 'none';
    void panel.offsetWidth;
    panel.style.animation = '';
  }
  function alignPanelArrow() {
    const proxy = resolveToolbarProxy();
    const arrow = resolvePanelArrow();
    if (!proxy || !arrow) {
      return;
    }
    const styles = getComputedStyle(document.documentElement);
    const panelWidth = parseFloat(styles.getPropertyValue('--fl-builder-panel-width')) || 320;
    const arrowWidth = arrow.getBoundingClientRect().width || 20;
    const buttonRect = proxy.getBoundingClientRect();
    const buttonCenterX = buttonRect.x + buttonRect.width / 2;
    const panelLeft = window.innerWidth - panelWidth;
    let arrowX = 20;
    if (buttonCenterX >= panelLeft) {
      arrowX = buttonCenterX - panelLeft - arrowWidth / 2;
    }
    arrow.style.left = Math.max(12, arrowX) + 'px';
    arrow.style.right = 'auto';
  }
  function debounce(fn, ms) {
    let t;
    return function () {
      clearTimeout(t);
      t = setTimeout(fn, ms);
    };
  }
  function findBarActions() {
    return document.querySelector('.fl-builder-bar-actions');
  }
  function findDoneButton() {
    const actions = findBarActions();
    return actions ? actions.querySelector('.fl-builder-done-button') : null;
  }
  function findPublishActionButton() {
    return document.querySelector('.fl-builder-publish-actions [data-action="publish"]');
  }
  let closeTimer = null;
  function bindProxyToggle(proxy) {
    if (!proxy || proxy.dataset.flowEwToggleBound === '1') {
      return;
    }
    proxy.dataset.flowEwToggleBound = '1';
    proxy.addEventListener('click', function (e) {
      e.preventDefault();
      e.stopPropagation();
      toggleDrawer();
    });
  }
  function syncToggleStatus(status) {
    const toggleEl = resolveToggle();
    const proxy = resolveToolbarProxy();
    const host = document.querySelector('.flow-ew-beaver-review');
    if (toggleEl) {
      toggleEl.dataset.status = status;
      toggleEl.setAttribute('data-status', status);
    }
    if (proxy) {
      proxy.dataset.status = status;
      proxy.setAttribute('data-status', status);
    }
    if (host) {
      host.setAttribute('data-status', status);
    }
  }
  function syncToolbarProxyActive(isActive) {
    const toggleEl = resolveToggle();
    const proxy = resolveToolbarProxy();
    [toggleEl, proxy].forEach(function (btn) {
      if (!btn) {
        return;
      }
      btn.classList.toggle('is-active', isActive);
      btn.setAttribute('aria-expanded', isActive ? 'true' : 'false');
    });
  }
  function isHostPlacedAfterDone(host, actions, doneBtn) {
    return host.parentElement === actions && host.previousElementSibling === doneBtn;
  }
  function ensureToolbarButton() {
    const toggleEl = resolveToggle();
    const actions = findBarActions();
    const doneBtn = findDoneButton();
    if (!toggleEl || !actions || !doneBtn) {
      return false;
    }
    let host = actions.querySelector('.flow-ew-beaver-review');
    if (!host) {
      host = document.createElement('span');
      host.className = 'flow-ew-beaver-review';
    }
    let proxy = host.querySelector('.flow-ew-beaver-toggle-proxy');
    if (!proxy) {
      proxy = document.createElement('button');
      proxy.type = 'button';
      proxy.className = toggleEl.className + ' flow-ew-beaver-toggle-proxy';
      if (toggleEl.getAttribute('aria-label')) {
        proxy.setAttribute('aria-label', toggleEl.getAttribute('aria-label'));
      }
      if (toggleEl.getAttribute('title')) {
        proxy.setAttribute('title', toggleEl.getAttribute('title'));
      }
      const icon = toggleEl.querySelector('.flow-ew-beaver-toggle__icon');
      proxy.innerHTML = icon ? icon.outerHTML : toggleEl.innerHTML;
      host.appendChild(proxy);
    }
    toggleEl.hidden = true;
    proxy.hidden = false;
    if (!isHostPlacedAfterDone(host, actions, doneBtn)) {
      const anchor = doneBtn.nextElementSibling;
      if (anchor && anchor !== host) {
        actions.insertBefore(host, anchor);
      } else {
        doneBtn.insertAdjacentElement('afterend', host);
      }
    }
    syncToggleStatus(toggleEl.dataset.status || '');
    syncToolbarProxyActive(isDrawerOpen());
    bindProxyToggle(proxy);
    alignPanelArrow();
    return true;
  }
  const debouncedEnsure = debounce(ensureToolbarButton, 80);
  const bodyObserver = new MutationObserver(debouncedEnsure);
  bodyObserver.observe(document.body, {
    childList: true,
    subtree: true
  });
  let attempts = 0;
  function tryEnsureLoop() {
    const ok = ensureToolbarButton();
    attempts++;
    if (!ok && attempts < 240) {
      requestAnimationFrame(tryEnsureLoop);
    }
  }
  tryEnsureLoop();
  function open() {
    const panel = getDrawer();
    if (!panel) {
      return;
    }
    if (closeTimer) {
      clearTimeout(closeTimer);
      closeTimer = null;
    }
    hideBeaverContentPanel();
    alignPanelArrow();
    panel.removeAttribute('hidden');
    document.body.classList.add('flow-ew-beaver-review-is-showing');
    replayPanelAnimation(panel);
    panel.classList.add('is-open');
    syncToolbarProxyActive(true);
  }
  function close() {
    const panel = getDrawer();
    if (!panel) {
      return;
    }
    panel.classList.remove('is-open');
    document.body.classList.remove('flow-ew-beaver-review-is-showing');
    syncToolbarProxyActive(false);
    if (closeTimer) {
      clearTimeout(closeTimer);
    }
    closeTimer = setTimeout(function () {
      closeTimer = null;
      const current = getDrawer();
      if (current && !current.classList.contains('is-open')) {
        current.setAttribute('hidden', '');
      }
    }, 150);
  }
  function toggleDrawer() {
    if (isDrawerOpen()) {
      close();
    } else {
      open();
    }
  }
  if (window.FLBuilder && typeof window.FLBuilder.addHook === 'function') {
    window.FLBuilder.addHook('willShowContentPanel', close);
  }
  window.addEventListener('resize', debounce(function () {
    if (isDrawerOpen()) {
      alignPanelArrow();
    }
  }, 80));
  const closeBtn = drawer.querySelector('.flow-ew-beaver-drawer__close');
  if (closeBtn && !closeBtn.dataset.flowEwCloseBound) {
    closeBtn.dataset.flowEwCloseBound = '1';
    closeBtn.addEventListener('click', function (e) {
      e.preventDefault();
      e.stopPropagation();
      close();
    });
  }
  document.addEventListener('keydown', function (e) {
    if (e.key === 'Escape' && isDrawerOpen()) {
      close();
    }
  });
  document.addEventListener('mousedown', function (e) {
    if (!isDrawerOpen()) {
      return;
    }
    const panel = getDrawer();
    if (!panel) {
      return;
    }
    if (panel.contains(e.target) || isToggleInteraction(e.target)) {
      return;
    }
    close();
  });
  const ew = window.flowEW || {};
  const reviewMandatory = !!ew.reviewMandatory;
  const isPublished = !!ew.isPublished;
  const reviewerMeta = Number(ew.reviewerMeta || 0);
  let lastReview = ew.activeReview || null;
  let publishGuardTimer;
  let blockedState = false;
  function currentReviewerId(review) {
    const fromReview = Number(review && review.reviewer_id || review && review.reviewer && review.reviewer.id || 0);
    return fromReview > 0 ? fromReview : reviewerMeta;
  }
  function isPublishBlocked(review) {
    if (!reviewMandatory) {
      return false;
    }
    if (isPublished) {
      return false;
    }
    if (!review || review.status !== 'approved') {
      return true;
    }
    return currentReviewerId(review) <= 0;
  }
  function applyPublishGuard(review) {
    blockedState = isPublishBlocked(review);
    document.body.classList.toggle('flow-ew-beaver-publish-blocked', blockedState);
    (0,_shared_publish_guard_ui__WEBPACK_IMPORTED_MODULE_2__.syncPublishGuardTooltip)(findPublishActionButton(), blockedState);
  }
  function schedulePublishGuard(review) {
    if (review !== undefined) {
      lastReview = review;
    }
    clearTimeout(publishGuardTimer);
    publishGuardTimer = setTimeout(function () {
      applyPublishGuard(lastReview);
    }, 80);
  }
  document.addEventListener('click', function (e) {
    if (!blockedState) {
      return;
    }
    const target = e.target;
    if (!target || !target.closest) {
      return;
    }
    if (target.closest('.flow-ew-beaver-toggle-proxy') || target.closest('.flow-ew-beaver-review-panel')) {
      return;
    }
    if (target.closest('.fl-builder-publish-actions [data-action="publish"]')) {
      e.preventDefault();
      e.stopImmediatePropagation();
    }
  }, true);
  const guardObserver = new MutationObserver(function () {
    schedulePublishGuard();
  });
  guardObserver.observe(document.body, {
    childList: true,
    subtree: true
  });
  schedulePublishGuard(lastReview);
  function syncReviewerComboboxFromReview(review) {
    const select = document.getElementById('flow-ew-reviewer-select');
    const input = document.getElementById('flow-ew-reviewer-input');
    if (!select || !input) {
      return;
    }
    const list = document.getElementById('flow-ew-reviewer-listbox');
    const rid = review ? Number(review.reviewer_id || review.reviewer && review.reviewer.id || 0) : 0;
    select.value = rid ? String(rid) : '';
    const opt = select.options[select.selectedIndex];
    input.value = opt && opt.value ? opt.textContent.replace(/^\s+|\s+$/g, '') : '';
    if (list) {
      list.querySelectorAll('[role="option"]').forEach(function (li) {
        const match = rid && Number(li.dataset.value) === rid;
        if (match) {
          li.setAttribute('aria-selected', 'true');
        } else {
          li.removeAttribute('aria-selected');
        }
      });
    }
  }
  function buildUpsellNode(data, className, linkMarginTop) {
    const wrap = document.createElement('div');
    wrap.className = className;
    wrap.setAttribute('data-flow-ew-beaver-upsell', '1');
    const link = document.createElement('a');
    link.href = data.href || '#';
    link.style.marginTop = linkMarginTop;
    const badge = document.createElement('span');
    badge.className = 'flow-ew-upsell-badge';
    badge.textContent = 'PRO';
    link.appendChild(badge);
    link.appendChild(document.createTextNode(data.label));
    wrap.appendChild(link);
    if (data.helpText) {
      const help = document.createElement('p');
      help.className = 'flow-ew-upsell-help';
      help.textContent = data.helpText;
      wrap.appendChild(help);
    }
    return wrap;
  }
  function getFallbackUpsellData(type) {
    const panel = getDrawer();
    if (!panel || panel.dataset.flowEwUpsellEnabled !== '1') {
      return null;
    }
    const href = panel.dataset.flowEwUpsellHref || '';
    if (!href) {
      return null;
    }
    if (type === 'open') {
      const label = panel.dataset.flowEwUpsellOpenLabel || '';
      if (!label) {
        return null;
      }
      return {
        href,
        label,
        helpText: panel.dataset.flowEwUpsellOpenHelp || ''
      };
    }
    const label = panel.dataset.flowEwUpsellReviewerLabel || '';
    if (!label) {
      return null;
    }
    return {
      href,
      label,
      helpText: panel.dataset.flowEwUpsellReviewerHelp || ''
    };
  }
  function syncFreeUpsells(review) {
    const panel = getDrawer();
    if (!panel) {
      return;
    }
    const openData = window.flowEwUpsell || getFallbackUpsellData('open');
    if (openData && openData.label) {
      panel.querySelectorAll('.flow-ew-open-review-extras').forEach(function (slot) {
        let node = slot.querySelector('.flow-ew-upsell-open-review');
        if (!node) {
          node = buildUpsellNode(openData, 'flow-ew-upsell-open-review', '6px');
          slot.appendChild(node);
        }
        const open = !!(review && review.is_open);
        node.style.display = open ? '' : 'none';
      });
    }
    const reviewerData = window.flowEwUpsellReviewer || getFallbackUpsellData('reviewer');
    const reviewerSelect = panel.querySelector('#flow-ew-reviewer-select');
    if (reviewerData && reviewerData.label && reviewerSelect) {
      const anchor = panel.querySelector('#flow-ew-reviewer-combobox') || reviewerSelect.parentElement;
      if (anchor && anchor.parentElement) {
        let node = anchor.parentElement.querySelector('.flow-ew-upsell-reviewer');
        const hasReviewer = Number(reviewerSelect.value || 0) > 0;
        if (hasReviewer && !node) {
          node = buildUpsellNode(reviewerData, 'flow-ew-upsell-reviewer', '14px');
          anchor.parentElement.insertBefore(node, anchor.nextSibling);
        }
        if (node) {
          node.style.display = hasReviewer ? '' : 'none';
        }
      }
      if (!reviewerSelect.dataset.flowBeaverUpsellBound) {
        reviewerSelect.dataset.flowBeaverUpsellBound = '1';
        reviewerSelect.addEventListener('change', function () {
          syncFreeUpsells(review);
        });
      }
    }
  }
  document.addEventListener('flow-ew:classic-render', function (e) {
    const review = e.detail && e.detail.review;
    const status = review && review.status || '';
    syncToggleStatus(status);
    syncReviewerComboboxFromReview(review);
    syncBeaverDarkSkin();
    schedulePublishGuard(review);
    syncFreeUpsells(review);
  });
  const comboboxRoot = document.getElementById('flow-ew-reviewer-combobox');
  if (comboboxRoot) {
    initReviewerCombobox(comboboxRoot);
  }
  syncFreeUpsells(lastReview);
  function initReviewerCombobox(root) {
    if (root.dataset.flowEwComboboxReady === '1') {
      return;
    }
    root.dataset.flowEwComboboxReady = '1';
    const input = root.querySelector('.flow-ew-reviewer-combobox__input');
    const list = root.querySelector('.flow-ew-reviewer-combobox__list');
    const select = root.querySelector('#flow-ew-reviewer-select');
    if (!input || !list || !select) {
      return;
    }
    const options = Array.from(list.querySelectorAll('[role="option"]'));
    let activeIndex = -1;
    function setOpen(openList) {
      list.hidden = !openList;
      input.setAttribute('aria-expanded', openList ? 'true' : 'false');
    }
    function filterOptions(q) {
      const needle = (q || '').toLowerCase().trim();
      options.forEach(function (li) {
        const label = (li.dataset.label || li.textContent || '').toLowerCase().trim();
        const show = !needle || label.includes(needle);
        li.hidden = !show;
        li.style.display = show ? '' : 'none';
      });
    }
    function visibleOptions() {
      return options.filter(function (li) {
        return !li.hidden && li.style.display !== 'none';
      });
    }
    function chooseOption(li) {
      if (!li || li.hidden) {
        return;
      }
      const id = li.dataset.value;
      const label = li.dataset.label || li.textContent.trim();
      select.value = id;
      input.value = label;
      setOpen(false);
      activeIndex = -1;
      select.dispatchEvent(new Event('change', {
        bubbles: true
      }));
    }
    input.addEventListener('focus', function () {
      if (input.disabled) {
        return;
      }
      filterOptions(input.value);
      setOpen(true);
    });
    input.addEventListener('input', function () {
      if (input.disabled) {
        return;
      }
      filterOptions(input.value);
      setOpen(true);
      activeIndex = -1;
    });
    list.addEventListener('mousedown', function (e) {
      const li = e.target.closest('[role="option"]');
      if (li && !li.hidden) {
        e.preventDefault();
        chooseOption(li);
      }
    });
    document.addEventListener('click', function (e) {
      if (!root.contains(e.target)) {
        setOpen(false);
        activeIndex = -1;
      }
    });
    input.addEventListener('keydown', function (e) {
      if (input.disabled) {
        return;
      }
      const vis = visibleOptions();
      if (e.key === 'ArrowDown') {
        e.preventDefault();
        if (!list.hidden && vis.length) {
          activeIndex = Math.min(activeIndex + 1, vis.length - 1);
          vis[activeIndex].focus();
        } else {
          filterOptions(input.value);
          setOpen(true);
          activeIndex = 0;
          if (vis[0]) {
            vis[0].focus();
          }
        }
      } else if (e.key === 'ArrowUp') {
        e.preventDefault();
        if (!list.hidden && vis.length) {
          activeIndex = Math.max(activeIndex - 1, 0);
          vis[activeIndex].focus();
        }
      } else if (e.key === 'Enter') {
        const focused = list.querySelector('[role="option"]:focus');
        if (focused && !focused.hidden) {
          e.preventDefault();
          chooseOption(focused);
        }
      } else if (e.key === 'Escape') {
        setOpen(false);
        activeIndex = -1;
        input.focus();
      }
    });
  }
})(0);

/***/ },

/***/ "./src/shared/publish-guard-ui.js"
/*!****************************************!*\
  !*** ./src/shared/publish-guard-ui.js ***!
  \****************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   applyPublishGuardControl: () => (/* binding */ applyPublishGuardControl),
/* harmony export */   findBricksPublishControl: () => (/* binding */ findBricksPublishControl),
/* harmony export */   getPublishGuardTooltip: () => (/* binding */ getPublishGuardTooltip),
/* harmony export */   publishGuardTooltipTarget: () => (/* binding */ publishGuardTooltipTarget),
/* harmony export */   syncGutenbergPublishGuardTooltips: () => (/* binding */ syncGutenbergPublishGuardTooltips),
/* harmony export */   syncPublishGuardTooltip: () => (/* binding */ syncPublishGuardTooltip)
/* harmony export */ });
/**
 * Shared publish-guard UI helpers (opacity lock + hover tooltip).
 */

function getPublishGuardTooltip() {
  const i18n = window.flowEW?.i18n || {};
  return i18n.publishGuardTooltip || 'Post can go live only after approval by a reviewer.';
}

/**
 * @param {Element|null|undefined} el
 * @returns {Element|null}
 */
function publishGuardTooltipTarget(el) {
  if (!el || !el.closest) {
    return null;
  }
  if (el.id === 'publish') {
    return el.closest('#publishing-action') || el.parentElement || el;
  }
  const panelToggle = el.closest('.editor-post-publish-panel__toggle, .editor-post-schedule__panel-dropdown');
  if (panelToggle) {
    return panelToggle;
  }
  return el.parentElement || el;
}

/**
 * @param {Element|null|undefined} el
 * @param {boolean} blocked
 */
function applyPublishGuardControl(el, blocked) {
  if (!el) {
    return;
  }
  const hint = getPublishGuardTooltip();
  const tooltipEl = publishGuardTooltipTarget(el);
  if (blocked) {
    el.style.opacity = '0.4';
    el.style.pointerEvents = 'none';
    el.style.cursor = 'not-allowed';
    if (tooltipEl) {
      tooltipEl.setAttribute('title', hint);
      tooltipEl.style.cursor = 'not-allowed';
      tooltipEl.dataset.flowEwPublishGuardTooltip = '1';
    }
    return;
  }
  el.style.opacity = '';
  el.style.pointerEvents = '';
  el.style.cursor = '';
  if (tooltipEl?.dataset.flowEwPublishGuardTooltip === '1') {
    tooltipEl.removeAttribute('title');
    tooltipEl.style.cursor = '';
    delete tooltipEl.dataset.flowEwPublishGuardTooltip;
  }
}
const GUTENBERG_TOOLTIP_SELECTORS = ['.edit-post-header .editor-post-publish-panel__toggle', '.edit-post-header .editor-post-publish-button'];

/**
 * @param {boolean} blocked
 */
function syncGutenbergPublishGuardTooltips(blocked) {
  const hint = getPublishGuardTooltip();
  GUTENBERG_TOOLTIP_SELECTORS.forEach(selector => {
    document.querySelectorAll(selector).forEach(el => {
      if (blocked) {
        el.setAttribute('title', hint);
        el.style.cursor = 'not-allowed';
        el.dataset.flowEwPublishGuardTooltip = '1';
        return;
      }
      if (el.dataset.flowEwPublishGuardTooltip === '1') {
        el.removeAttribute('title');
        el.style.cursor = '';
        delete el.dataset.flowEwPublishGuardTooltip;
      }
    });
  });
}

/**
 * @param {Element|null|undefined} el
 * @param {boolean} blocked
 */
function syncPublishGuardTooltip(el, blocked) {
  if (!el) {
    return;
  }
  const hint = getPublishGuardTooltip();
  if (blocked) {
    el.setAttribute('title', hint);
    el.dataset.flowEwPublishGuardTooltip = '1';
    return;
  }
  if (el.dataset.flowEwPublishGuardTooltip === '1') {
    el.removeAttribute('title');
    delete el.dataset.flowEwPublishGuardTooltip;
  }
}

/** @returns {Element|null} */
function findBricksPublishControl() {
  return document.querySelector('#bricks-toolbar li:has([data-name="publish"])');
}

/***/ },

/***/ "./src/beaver/style.css"
/*!******************************!*\
  !*** ./src/beaver/style.css ***!
  \******************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ },

/***/ "./src/shared/share-bar.css"
/*!**********************************!*\
  !*** ./src/shared/share-bar.css ***!
  \**********************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
// extracted by mini-css-extract-plugin


/***/ }

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		if (!(moduleId in __webpack_modules__)) {
/******/ 			delete __webpack_module_cache__[moduleId];
/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
/******/ 			e.code = 'MODULE_NOT_FOUND';
/******/ 			throw e;
/******/ 		}
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = __webpack_modules__;
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/chunk loaded */
/******/ 	(() => {
/******/ 		var deferred = [];
/******/ 		__webpack_require__.O = (result, chunkIds, fn, priority) => {
/******/ 			if(chunkIds) {
/******/ 				priority = priority || 0;
/******/ 				for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
/******/ 				deferred[i] = [chunkIds, fn, priority];
/******/ 				return;
/******/ 			}
/******/ 			var notFulfilled = Infinity;
/******/ 			for (var i = 0; i < deferred.length; i++) {
/******/ 				var [chunkIds, fn, priority] = deferred[i];
/******/ 				var fulfilled = true;
/******/ 				for (var j = 0; j < chunkIds.length; j++) {
/******/ 					if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
/******/ 						chunkIds.splice(j--, 1);
/******/ 					} else {
/******/ 						fulfilled = false;
/******/ 						if(priority < notFulfilled) notFulfilled = priority;
/******/ 					}
/******/ 				}
/******/ 				if(fulfilled) {
/******/ 					deferred.splice(i--, 1)
/******/ 					var r = fn();
/******/ 					if (r !== undefined) result = r;
/******/ 				}
/******/ 			}
/******/ 			return result;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/jsonp chunk loading */
/******/ 	(() => {
/******/ 		// no baseURI
/******/ 		
/******/ 		// object to store loaded and loading chunks
/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
/******/ 		var installedChunks = {
/******/ 			"beaver/index": 0,
/******/ 			"beaver/style-index": 0
/******/ 		};
/******/ 		
/******/ 		// no chunk on demand loading
/******/ 		
/******/ 		// no prefetching
/******/ 		
/******/ 		// no preloaded
/******/ 		
/******/ 		// no HMR
/******/ 		
/******/ 		// no HMR manifest
/******/ 		
/******/ 		__webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);
/******/ 		
/******/ 		// install a JSONP callback for chunk loading
/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
/******/ 			var [chunkIds, moreModules, runtime] = data;
/******/ 			// add "moreModules" to the modules object,
/******/ 			// then flag all "chunkIds" as loaded and fire callback
/******/ 			var moduleId, chunkId, i = 0;
/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
/******/ 				for(moduleId in moreModules) {
/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ 					}
/******/ 				}
/******/ 				if(runtime) var result = runtime(__webpack_require__);
/******/ 			}
/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
/******/ 			for(;i < chunkIds.length; i++) {
/******/ 				chunkId = chunkIds[i];
/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
/******/ 					installedChunks[chunkId][0]();
/******/ 				}
/******/ 				installedChunks[chunkId] = 0;
/******/ 			}
/******/ 			return __webpack_require__.O(result);
/******/ 		}
/******/ 		
/******/ 		var chunkLoadingGlobal = globalThis["webpackChunkjumplinks_editorial_workflow"] = globalThis["webpackChunkjumplinks_editorial_workflow"] || [];
/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
/******/ 	})();
/******/ 	
/************************************************************************/
/******/ 	
/******/ 	// startup
/******/ 	// Load entry module and return exports
/******/ 	// This entry module depends on other loaded chunks and execution need to be delayed
/******/ 	var __webpack_exports__ = __webpack_require__.O(undefined, ["beaver/style-index"], () => (__webpack_require__("./src/beaver/index.js")))
/******/ 	__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ 	
/******/ })()
;
//# sourceMappingURL=index.js.map