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

/***/ "./src/elementor/index.js"
/*!********************************!*\
  !*** ./src/elementor/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/elementor/style.css");
/* harmony import */ var _shared_review_notice_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../shared/review-notice-dom */ "./src/shared/review-notice-dom.js");


(function bootElementorReview(attempt) {
  const drawer = document.getElementById('flow-ew-elementor-drawer');
  const toggle = document.getElementById('flow-ew-elementor-toggle');
  if (!drawer || !toggle) {
    if (attempt < 150) {
      requestAnimationFrame(function () {
        bootElementorReview(attempt + 1);
      });
    }
    return;
  }
  if (drawer.dataset.flowEwElementorReady === '1') {
    return;
  }
  drawer.dataset.flowEwElementorReady = '1';
  (function runElementorReview(drawer, toggle) {
    function debounce(fn, ms) {
      let t;
      return function () {
        clearTimeout(t);
        t = setTimeout(fn, ms);
      };
    }
    function findPublishButton(root) {
      if (!root) {
        return null;
      }
      const preferred = root.querySelectorAll('button.MuiButton-root.MuiButton-containedPrimary');
      for (let i = 0; i < preferred.length; i++) {
        const b = preferred[i];
        if (b.offsetParent !== null) {
          return b;
        }
      }

      // Fallback for older Elementor builds where primary styles differ.
      const buttons = root.querySelectorAll('button.MuiButton-root');
      for (let i = 0; i < buttons.length; i++) {
        const b = buttons[i];
        if (b.offsetParent === null) {
          continue;
        }
        const label = b.textContent.replace(/\s+/g, ' ').trim();
        if (/^(Publish|Submit)$/i.test(label)) {
          return b;
        }
      }
      return null;
    }
    function pickTopBarAnchor(root) {
      if (!root) {
        return null;
      }
      const buttons = Array.from(root.querySelectorAll('button.MuiButton-root')).filter(b => b.offsetParent !== null);
      if (!buttons.length) {
        return null;
      }
      const topButtons = buttons.filter(b => {
        const rect = b.getBoundingClientRect();
        return rect.top >= 0 && rect.top < 170;
      });
      const source = topButtons.length ? topButtons : buttons;
      source.sort((a, b) => b.getBoundingClientRect().right - a.getBoundingClientRect().right);
      return source[0] || null;
    }
    function findToolbarIconButtonRef(parent, roots) {
      if (parent) {
        const inParent = parent.querySelector('button.MuiIconButton-root');
        if (inParent && inParent.offsetParent !== null) {
          return inParent;
        }
      }
      for (let i = 0; i < roots.length; i++) {
        const btn = roots[i].querySelector('button.MuiIconButton-root');
        if (btn && btn.offsetParent !== null) {
          return btn;
        }
      }
      return null;
    }
    function syncInlineToggleMetrics(roots, parent) {
      if (!toggle.classList.contains('flow-ew-elementor-toggle--inline')) {
        toggle.style.width = '';
        toggle.style.height = '';
        toggle.style.alignSelf = '';
        return;
      }
      const ref = findToolbarIconButtonRef(parent, roots);
      if (ref) {
        const cs = window.getComputedStyle(ref);
        toggle.style.width = cs.width;
        toggle.style.height = cs.height;
        toggle.style.alignSelf = cs.alignSelf || 'center';
        return;
      }
      toggle.style.width = '';
      toggle.style.height = '';
      toggle.style.alignSelf = 'center';
    }
    function anchorToggleNearPublish() {
      const roots = [document.getElementById('elementor-editor-wrapper-v2'), document.getElementById('elementor-editor-wrapper')].filter(Boolean);
      let publish = null;
      for (let i = 0; i < roots.length; i++) {
        publish = findPublishButton(roots[i]);
        if (publish) {
          break;
        }
      }
      let anchor = publish;
      if (!anchor) {
        for (let i = 0; i < roots.length; i++) {
          anchor = pickTopBarAnchor(roots[i]);
          if (anchor) {
            break;
          }
        }
      }
      const parent = anchor && anchor.parentElement;
      if (parent && anchor) {
        // Inline next to Publish in the top bar. Skip if already in place
        // to avoid bouncing the MutationObserver.
        if (toggle.parentElement !== parent || toggle.nextSibling !== anchor) {
          parent.insertBefore(toggle, anchor);
        }
        syncInlineToggleMetrics(roots, parent);
        toggle.style.position = '';
        toggle.style.top = '';
        toggle.style.left = '';
        toggle.style.right = '';
        toggle.classList.remove('flow-ew-elementor-toggle--fallback');
        toggle.classList.remove('flow-ew-elementor-toggle--anchored');
        toggle.classList.add('flow-ew-elementor-toggle--inline');
      } else {
        // Only use floating fallback when the editor chrome itself is missing.
        const toolbarReady = roots.some(root => !!pickTopBarAnchor(root));
        if (!toolbarReady) {
          toggle.style.position = 'fixed';
          toggle.style.top = '';
          toggle.style.left = '';
          toggle.style.right = '';
          toggle.style.width = '';
          toggle.style.height = '';
          toggle.style.alignSelf = '';
          toggle.classList.add('flow-ew-elementor-toggle--fallback');
          toggle.classList.remove('flow-ew-elementor-toggle--anchored');
          toggle.classList.remove('flow-ew-elementor-toggle--inline');
        }
      }
    }
    const debouncedAnchor = debounce(anchorToggleNearPublish, 80);
    window.addEventListener('resize', debouncedAnchor);
    const observeRoots = [document.getElementById('elementor-editor-wrapper-v2'), document.getElementById('elementor-editor-wrapper')].filter(Boolean);
    for (let r = 0; r < observeRoots.length; r++) {
      new MutationObserver(debouncedAnchor).observe(observeRoots[r], {
        childList: true,
        subtree: true
      });
    }
    let anchorAttempts = 0;
    function tryAnchorLoop() {
      anchorToggleNearPublish();
      anchorAttempts++;
      if (anchorAttempts < 180 && !toggle.classList.contains('flow-ew-elementor-toggle--inline')) {
        requestAnimationFrame(tryAnchorLoop);
      }
    }
    tryAnchorLoop();

    // Anchor the popup directly under the Review toggle, right-aligned to it
    // so it never overflows past the top bar's right edge.
    function positionPopup() {
      const rect = toggle.getBoundingClientRect();
      drawer.style.top = rect.bottom + 6 + 'px';
      drawer.style.right = window.innerWidth - rect.right + 'px';
      drawer.style.left = 'auto';
    }
    function refreshReviewNotices() {
      const ew = window.flowEW;
      if (!ew) {
        return;
      }
      (0,_shared_review_notice_dom__WEBPACK_IMPORTED_MODULE_1__.ensureReviewNotices)({
        reviewMandatory: ew.reviewMandatory,
        isPublished: ew.isPublished,
        review: ew.activeReview,
        reviewerMeta: ew.reviewerMeta,
        currentUserCan: ew.currentUserCan
      });
    }
    function open() {
      drawer.style.display = '';
      positionPopup();
      drawer.classList.add('is-open');
      toggle.classList.add('is-active');
      refreshReviewNotices();
    }
    function close() {
      drawer.classList.remove('is-open');
      toggle.classList.remove('is-active');
      setTimeout(function () {
        if (!drawer.classList.contains('is-open')) {
          drawer.style.display = 'none';
        }
      }, 150);
    }
    toggle.addEventListener('click', function () {
      if (drawer.classList.contains('is-open')) {
        close();
      } else {
        open();
      }
    });
    const closeBtn = drawer.querySelector('.flow-ew-elementor-drawer__close');
    if (closeBtn) {
      closeBtn.addEventListener('click', close);
    }
    document.addEventListener('keydown', function (e) {
      if (e.key === 'Escape' && drawer.classList.contains('is-open')) {
        close();
      }
    });

    // Click outside the popup closes it.
    document.addEventListener('mousedown', function (e) {
      if (!drawer.classList.contains('is-open')) {
        return;
      }
      if (drawer.contains(e.target) || toggle.contains(e.target)) {
        return;
      }
      close();
    });

    // Reposition on layout changes while open.
    window.addEventListener('resize', function () {
      if (drawer.classList.contains('is-open')) {
        positionPopup();
      }
    });
    function flowReviewStatusApproved() {
      const ds = toggle && toggle.dataset && toggle.dataset.status;
      if (ds === 'approved') {
        return true;
      }
      const ew = window.flowEW;
      return !!(ew && ew.activeReview && ew.activeReview.status === 'approved');
    }
    function tryElementorSetDocumentModified() {
      if (!flowReviewStatusApproved()) {
        return;
      }
      try {
        if (window.$e && typeof window.$e.internal === 'function') {
          window.$e.internal('document/save/set-is-modified', {
            status: true
          });
          return;
        }
      } catch (_) {
        // Command missing or editor not ready.
      }
      try {
        const doc = window.elementor && window.elementor.documents && window.elementor.documents.getCurrent && window.elementor.documents.getCurrent();
        if (doc && doc.editor) {
          doc.editor.isChanged = true;
          doc.editor.isSaved = false;
        }
        if (window.elementor && window.elementor.channels && window.elementor.channels.editor) {
          window.elementor.channels.editor.reply('status', true).trigger('status:change', true);
        }
      } catch (_) {
        // Legacy paths unavailable.
      }
    }
    function scheduleTryElementorSetDocumentModified() {
      window.requestAnimationFrame(function () {
        tryElementorSetDocumentModified();
        window.setTimeout(tryElementorSetDocumentModified, 150);
        window.setTimeout(tryElementorSetDocumentModified, 600);
      });
    }
    document.addEventListener('flow-ew:classic-render', function (e) {
      const review = e.detail && e.detail.review;
      toggle.dataset.status = review && review.status || '';
      syncReviewerComboboxFromReview(review);
      scheduleTryElementorSetDocumentModified();
    });
    document.addEventListener('flow-ew:reload-review', function () {
      window.setTimeout(scheduleTryElementorSetDocumentModified, 600);
    });
    if (window.jQuery) {
      window.jQuery(window).on('elementor:init', function () {
        scheduleTryElementorSetDocumentModified();
      });
    }
    if (flowReviewStatusApproved()) {
      scheduleTryElementorSetDocumentModified();
    }
    function onElementorSave() {
      setTimeout(function () {
        document.dispatchEvent(new CustomEvent('flow-ew:reload-review'));
      }, 500);
    }
    if (window.elementor) {
      try {
        window.elementor.on('document:saved', onElementorSave);
      } catch (_) {
        // Older Elementor.
      }
    }
    if (window.jQuery) {
      window.jQuery(document).on('heartbeat-tick.wp-refresh-nonces', function () {
        setTimeout(function () {
          document.dispatchEvent(new CustomEvent('flow-ew:reload-review'));
        }, 500);
      });
    }

    /* Reviewer combobox (Elementor drawer only) */
    const comboboxRoot = drawer.querySelector('#flow-ew-reviewer-combobox');
    if (comboboxRoot) {
      initReviewerCombobox(comboboxRoot);
    }
    function syncReviewerComboboxFromReview(review) {
      const select = drawer.querySelector('#flow-ew-reviewer-select');
      const input = drawer.querySelector('#flow-ew-reviewer-input');
      if (!select || !input) {
        return;
      }
      const list = drawer.querySelector('#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 initReviewerCombobox(root) {
      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();
        }
      });
    }
    refreshReviewNotices();
  })(drawer, toggle);
})(0);

/***/ },

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

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   isPublishBlocked: () => (/* binding */ isPublishBlocked)
/* harmony export */ });
/**
 * Mirrors PublishGuard / classic-editor publish blocking — show review
 * notices only while this returns true.
 *
 * @param {{
 *   reviewMandatory?: boolean,
 *   isPublished?: boolean,
 *   review?: object|null,
 *   reviewerMeta?: number,
 * }} args
 */
function isPublishBlocked({
  reviewMandatory,
  isPublished,
  review,
  reviewerMeta = 0
}) {
  if (!reviewMandatory || isPublished) {
    return false;
  }
  const fromReview = Number(review?.reviewer_id ?? review?.reviewer?.id ?? 0);
  const fromMeta = Number(reviewerMeta ?? 0);
  const reviewerId = fromReview > 0 ? fromReview : fromMeta;
  return !(review?.status === 'approved' && reviewerId > 0);
}

/***/ },

/***/ "./src/shared/resolve-classic-root.js"
/*!********************************************!*\
  !*** ./src/shared/resolve-classic-root.js ***!
  \********************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   resolveClassicOpenSlot: () => (/* binding */ resolveClassicOpenSlot),
/* harmony export */   resolveClassicRoot: () => (/* binding */ resolveClassicRoot)
/* harmony export */ });
/**
 * Prefer the visible builder drawer panel over the Classic Editor metabox.
 * On `post.php?action=elementor` both can exist in the DOM with duplicate IDs.
 */
function resolveClassicRoot() {
  const builderSelectors = ['#flow-ew-elementor-drawer #flow-ew-classic', '#flow-ew-bricks-drawer #flow-ew-classic', '#flow-ew-breakdance-drawer #flow-ew-classic', '#flow-ew-avada-drawer #flow-ew-classic', '#flow-ew-beaver-drawer #flow-ew-classic', '#flow-ew-divi-drawer #flow-ew-classic'];
  for (let i = 0; i < builderSelectors.length; i++) {
    const el = document.querySelector(builderSelectors[i]);
    if (el) {
      return el;
    }
  }
  return document.getElementById('flow-ew-classic');
}
function resolveClassicOpenSlot() {
  const builderSelectors = ['#flow-ew-elementor-drawer #flow-ew-classic-open-slot', '#flow-ew-bricks-drawer #flow-ew-classic-open-slot', '#flow-ew-breakdance-drawer #flow-ew-classic-open-slot', '#flow-ew-avada-drawer #flow-ew-classic-open-slot', '#flow-ew-beaver-drawer #flow-ew-classic-open-slot', '#flow-ew-divi-drawer #flow-ew-classic-open-slot'];
  for (let i = 0; i < builderSelectors.length; i++) {
    const el = document.querySelector(builderSelectors[i]);
    if (el) {
      return el;
    }
  }
  return document.getElementById('flow-ew-classic-open-slot');
}

/***/ },

/***/ "./src/shared/review-notice-dom.js"
/*!*****************************************!*\
  !*** ./src/shared/review-notice-dom.js ***!
  \*****************************************/
(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   ensureReviewNotices: () => (/* binding */ ensureReviewNotices),
/* harmony export */   syncReviewNoticeVisibility: () => (/* binding */ syncReviewNoticeVisibility)
/* harmony export */ });
/* harmony import */ var _is_publish_blocked__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./is-publish-blocked */ "./src/shared/is-publish-blocked.js");
/* harmony import */ var _resolve_classic_root__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./resolve-classic-root */ "./src/shared/resolve-classic-root.js");


function escHtml(str) {
  const d = document.createElement('div');
  d.textContent = str;
  return d.innerHTML;
}
function collectClassicRoots() {
  const roots = [];
  const primary = (0,_resolve_classic_root__WEBPACK_IMPORTED_MODULE_1__.resolveClassicRoot)();
  if (primary) {
    roots.push(primary);
  }
  document.querySelectorAll('#flow-ew-classic').forEach(el => {
    if (!roots.includes(el)) {
      roots.push(el);
    }
  });
  return roots;
}

/**
 * Toggle publish-guard notices. Works on PHP-rendered and JS-fallback notices.
 */
function syncReviewNoticeVisibility(args) {
  const blocked = (0,_is_publish_blocked__WEBPACK_IMPORTED_MODULE_0__.isPublishBlocked)(args);
  document.querySelectorAll('.flow-ew-review-notice').forEach(el => {
    if (el.dataset.flowEwPublishGuardOnly === '1') {
      el.hidden = !blocked;
      return;
    }
    el.hidden = false;
  });
}
function buildNoticeSpec(flowEW, review, publishBlocked) {
  const i18n = flowEW.i18n || {};
  const noReviewers = !!flowEW.noReviewers;
  const reviewMandatory = !!flowEW.reviewMandatory;
  if (noReviewers && !reviewMandatory) {
    return {
      variant: 'in-review',
      role: 'alert',
      publishGuardOnly: false,
      title: i18n.noReviewRolesTitle || 'No Review Roles Assigned',
      descHtml: flowEW.reviewRolesHintHtml || ''
    };
  }
  if (!publishBlocked) {
    return null;
  }
  if (noReviewers) {
    const descParts = [i18n.reviewMandatoryDesc || i18n.publishGuardTooltip || 'Post can go live only after approval by a reviewer.'];
    if (flowEW.reviewRolesHintHtml) {
      descParts.push(flowEW.reviewRolesHintHtml);
    }
    return {
      variant: 'changes-requested',
      role: 'alert',
      publishGuardOnly: true,
      title: i18n.noReviewRolesTitle || 'No Review Roles Assigned',
      descHtml: descParts.join(' ')
    };
  }
  return {
    variant: 'in-review',
    role: 'note',
    publishGuardOnly: true,
    title: i18n.reviewMandatoryTitle || 'Review Mode set to Mandatory',
    descHtml: i18n.reviewMandatoryDesc || i18n.publishGuardTooltip || 'Post can go live only after approval by a reviewer.'
  };
}
function renderNoticeElement(spec) {
  const div = document.createElement('div');
  div.className = 'flow-ew-review-notice flow-ew-review-notice--' + spec.variant;
  div.setAttribute('role', spec.role);
  div.dataset.flowEwJsNotice = '1';
  if (spec.publishGuardOnly) {
    div.dataset.flowEwPublishGuardOnly = '1';
  }
  div.innerHTML = '<p class="flow-ew-review-notice__title">' + escHtml(spec.title) + '</p>' + '<p class="flow-ew-review-notice__desc">' + spec.descHtml + '</p>';
  return div;
}
function insertNotice(root, notice) {
  const anchor = root.querySelector('#flow-ew-classic-open-slot') || root.firstElementChild;
  if (anchor) {
    anchor.insertAdjacentElement('afterend', notice);
    return;
  }
  root.prepend(notice);
}

/**
 * Ensure review mode notices exist in builder/classic panels (SSR fallback).
 */
function ensureReviewNotices({
  review,
  reviewMandatory,
  reviewerMeta,
  isPublished,
  currentUserCan
}) {
  const flowEW = window.flowEW;
  if (!flowEW || !currentUserCan?.assignReviewer) {
    document.querySelectorAll('.flow-ew-review-notice[data-flow-ew-js-notice="1"]').forEach(el => el.remove());
    syncReviewNoticeVisibility({
      reviewMandatory,
      isPublished,
      review,
      reviewerMeta
    });
    return;
  }
  const publishBlocked = (0,_is_publish_blocked__WEBPACK_IMPORTED_MODULE_0__.isPublishBlocked)({
    reviewMandatory,
    isPublished,
    review,
    reviewerMeta
  });
  const spec = buildNoticeSpec(flowEW, review, publishBlocked);
  collectClassicRoots().forEach(root => {
    const jsNotice = root.querySelector('.flow-ew-review-notice[data-flow-ew-js-notice="1"]');
    const hasPhpNotice = root.querySelector('.flow-ew-review-notice:not([data-flow-ew-js-notice])');
    if (!spec) {
      if (jsNotice) {
        jsNotice.remove();
      }
      return;
    }
    if (hasPhpNotice) {
      if (jsNotice) {
        jsNotice.remove();
      }
      return;
    }
    if (jsNotice) {
      const next = renderNoticeElement(spec);
      jsNotice.replaceWith(next);
      return;
    }
    insertNotice(root, renderNoticeElement(spec));
  });
  syncReviewNoticeVisibility({
    reviewMandatory,
    isPublished,
    review,
    reviewerMeta
  });
}

/***/ },

/***/ "./src/elementor/style.css"
/*!*********************************!*\
  !*** ./src/elementor/style.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 = {
/******/ 			"elementor/index": 0,
/******/ 			"elementor/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, ["elementor/style-index"], () => (__webpack_require__("./src/elementor/index.js")))
/******/ 	__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ 	
/******/ })()
;
//# sourceMappingURL=index.js.map