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

/***/ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js":
/*!******************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js ***!
  \******************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ _extends; }
/* harmony export */ });
function _extends() {
  return _extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e < arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
    }
    return n;
  }, _extends.apply(null, arguments);
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js":
/*!*****************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js ***!
  \*****************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   HiddenText: function() { return /* binding */ HiddenText; },
/* harmony export */   LiveRegion: function() { return /* binding */ LiveRegion; },
/* harmony export */   useAnnouncement: function() { return /* binding */ useAnnouncement; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);


const hiddenStyles = {
  display: 'none'
};
function HiddenText(_ref) {
  let {
    id,
    value
  } = _ref;
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", {
    id: id,
    style: hiddenStyles
  }, value);
}

function LiveRegion(_ref) {
  let {
    id,
    announcement,
    ariaLiveType = "assertive"
  } = _ref;
  // Hide element visually but keep it readable by screen readers
  const visuallyHidden = {
    position: 'fixed',
    top: 0,
    left: 0,
    width: 1,
    height: 1,
    margin: -1,
    border: 0,
    padding: 0,
    overflow: 'hidden',
    clip: 'rect(0 0 0 0)',
    clipPath: 'inset(100%)',
    whiteSpace: 'nowrap'
  };
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement("div", {
    id: id,
    style: visuallyHidden,
    role: "status",
    "aria-live": ariaLiveType,
    "aria-atomic": true
  }, announcement);
}

function useAnnouncement() {
  const [announcement, setAnnouncement] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)('');
  const announce = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(value => {
    if (value != null) {
      setAnnouncement(value);
    }
  }, []);
  return {
    announce,
    announcement
  };
}


//# sourceMappingURL=accessibility.esm.js.map


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/core/dist/core.esm.js":
/*!***********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@dnd-kit/core/dist/core.esm.js ***!
  \***********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AutoScrollActivator: function() { return /* binding */ AutoScrollActivator; },
/* harmony export */   DndContext: function() { return /* binding */ DndContext; },
/* harmony export */   DragOverlay: function() { return /* binding */ DragOverlay; },
/* harmony export */   KeyboardCode: function() { return /* binding */ KeyboardCode; },
/* harmony export */   KeyboardSensor: function() { return /* binding */ KeyboardSensor; },
/* harmony export */   MeasuringFrequency: function() { return /* binding */ MeasuringFrequency; },
/* harmony export */   MeasuringStrategy: function() { return /* binding */ MeasuringStrategy; },
/* harmony export */   MouseSensor: function() { return /* binding */ MouseSensor; },
/* harmony export */   PointerSensor: function() { return /* binding */ PointerSensor; },
/* harmony export */   TouchSensor: function() { return /* binding */ TouchSensor; },
/* harmony export */   TraversalOrder: function() { return /* binding */ TraversalOrder; },
/* harmony export */   applyModifiers: function() { return /* binding */ applyModifiers; },
/* harmony export */   closestCenter: function() { return /* binding */ closestCenter; },
/* harmony export */   closestCorners: function() { return /* binding */ closestCorners; },
/* harmony export */   defaultAnnouncements: function() { return /* binding */ defaultAnnouncements; },
/* harmony export */   defaultCoordinates: function() { return /* binding */ defaultCoordinates; },
/* harmony export */   defaultDropAnimation: function() { return /* binding */ defaultDropAnimationConfiguration; },
/* harmony export */   defaultDropAnimationSideEffects: function() { return /* binding */ defaultDropAnimationSideEffects; },
/* harmony export */   defaultKeyboardCoordinateGetter: function() { return /* binding */ defaultKeyboardCoordinateGetter; },
/* harmony export */   defaultScreenReaderInstructions: function() { return /* binding */ defaultScreenReaderInstructions; },
/* harmony export */   getClientRect: function() { return /* binding */ getClientRect; },
/* harmony export */   getFirstCollision: function() { return /* binding */ getFirstCollision; },
/* harmony export */   getScrollableAncestors: function() { return /* binding */ getScrollableAncestors; },
/* harmony export */   pointerWithin: function() { return /* binding */ pointerWithin; },
/* harmony export */   rectIntersection: function() { return /* binding */ rectIntersection; },
/* harmony export */   useDndContext: function() { return /* binding */ useDndContext; },
/* harmony export */   useDndMonitor: function() { return /* binding */ useDndMonitor; },
/* harmony export */   useDraggable: function() { return /* binding */ useDraggable; },
/* harmony export */   useDroppable: function() { return /* binding */ useDroppable; },
/* harmony export */   useSensor: function() { return /* binding */ useSensor; },
/* harmony export */   useSensors: function() { return /* binding */ useSensors; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react-dom */ "react-dom");
/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react_dom__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @dnd-kit/utilities */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/utilities/dist/utilities.esm.js");
/* harmony import */ var _dnd_kit_accessibility__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @dnd-kit/accessibility */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/accessibility/dist/accessibility.esm.js");





const DndMonitorContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(null);

function useDndMonitor(listener) {
  const registerListener = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(DndMonitorContext);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (!registerListener) {
      throw new Error('useDndMonitor must be used within a children of <DndContext>');
    }

    const unsubscribe = registerListener(listener);
    return unsubscribe;
  }, [listener, registerListener]);
}

function useDndMonitorProvider() {
  const [listeners] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(() => new Set());
  const registerListener = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(listener => {
    listeners.add(listener);
    return () => listeners.delete(listener);
  }, [listeners]);
  const dispatch = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(_ref => {
    let {
      type,
      event
    } = _ref;
    listeners.forEach(listener => {
      var _listener$type;

      return (_listener$type = listener[type]) == null ? void 0 : _listener$type.call(listener, event);
    });
  }, [listeners]);
  return [dispatch, registerListener];
}

const defaultScreenReaderInstructions = {
  draggable: "\n    To pick up a draggable item, press the space bar.\n    While dragging, use the arrow keys to move the item.\n    Press space again to drop the item in its new position, or press escape to cancel.\n  "
};
const defaultAnnouncements = {
  onDragStart(_ref) {
    let {
      active
    } = _ref;
    return "Picked up draggable item " + active.id + ".";
  },

  onDragOver(_ref2) {
    let {
      active,
      over
    } = _ref2;

    if (over) {
      return "Draggable item " + active.id + " was moved over droppable area " + over.id + ".";
    }

    return "Draggable item " + active.id + " is no longer over a droppable area.";
  },

  onDragEnd(_ref3) {
    let {
      active,
      over
    } = _ref3;

    if (over) {
      return "Draggable item " + active.id + " was dropped over droppable area " + over.id;
    }

    return "Draggable item " + active.id + " was dropped.";
  },

  onDragCancel(_ref4) {
    let {
      active
    } = _ref4;
    return "Dragging was cancelled. Draggable item " + active.id + " was dropped.";
  }

};

function Accessibility(_ref) {
  let {
    announcements = defaultAnnouncements,
    container,
    hiddenTextDescribedById,
    screenReaderInstructions = defaultScreenReaderInstructions
  } = _ref;
  const {
    announce,
    announcement
  } = (0,_dnd_kit_accessibility__WEBPACK_IMPORTED_MODULE_3__.useAnnouncement)();
  const liveRegionId = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useUniqueId)("DndLiveRegion");
  const [mounted, setMounted] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(false);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    setMounted(true);
  }, []);
  useDndMonitor((0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    onDragStart(_ref2) {
      let {
        active
      } = _ref2;
      announce(announcements.onDragStart({
        active
      }));
    },

    onDragMove(_ref3) {
      let {
        active,
        over
      } = _ref3;

      if (announcements.onDragMove) {
        announce(announcements.onDragMove({
          active,
          over
        }));
      }
    },

    onDragOver(_ref4) {
      let {
        active,
        over
      } = _ref4;
      announce(announcements.onDragOver({
        active,
        over
      }));
    },

    onDragEnd(_ref5) {
      let {
        active,
        over
      } = _ref5;
      announce(announcements.onDragEnd({
        active,
        over
      }));
    },

    onDragCancel(_ref6) {
      let {
        active,
        over
      } = _ref6;
      announce(announcements.onDragCancel({
        active,
        over
      }));
    }

  }), [announce, announcements]));

  if (!mounted) {
    return null;
  }

  const markup = react__WEBPACK_IMPORTED_MODULE_0___default().createElement((react__WEBPACK_IMPORTED_MODULE_0___default().Fragment), null, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(_dnd_kit_accessibility__WEBPACK_IMPORTED_MODULE_3__.HiddenText, {
    id: hiddenTextDescribedById,
    value: screenReaderInstructions.draggable
  }), react__WEBPACK_IMPORTED_MODULE_0___default().createElement(_dnd_kit_accessibility__WEBPACK_IMPORTED_MODULE_3__.LiveRegion, {
    id: liveRegionId,
    announcement: announcement
  }));
  return container ? (0,react_dom__WEBPACK_IMPORTED_MODULE_1__.createPortal)(markup, container) : markup;
}

var Action;

(function (Action) {
  Action["DragStart"] = "dragStart";
  Action["DragMove"] = "dragMove";
  Action["DragEnd"] = "dragEnd";
  Action["DragCancel"] = "dragCancel";
  Action["DragOver"] = "dragOver";
  Action["RegisterDroppable"] = "registerDroppable";
  Action["SetDroppableDisabled"] = "setDroppableDisabled";
  Action["UnregisterDroppable"] = "unregisterDroppable";
})(Action || (Action = {}));

function noop() {}

function useSensor(sensor, options) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    sensor,
    options: options != null ? options : {}
  }), // eslint-disable-next-line react-hooks/exhaustive-deps
  [sensor, options]);
}

function useSensors() {
  for (var _len = arguments.length, sensors = new Array(_len), _key = 0; _key < _len; _key++) {
    sensors[_key] = arguments[_key];
  }

  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => [...sensors].filter(sensor => sensor != null), // eslint-disable-next-line react-hooks/exhaustive-deps
  [...sensors]);
}

const defaultCoordinates = /*#__PURE__*/Object.freeze({
  x: 0,
  y: 0
});

/**
 * Returns the distance between two points
 */
function distanceBetween(p1, p2) {
  return Math.sqrt(Math.pow(p1.x - p2.x, 2) + Math.pow(p1.y - p2.y, 2));
}

function getRelativeTransformOrigin(event, rect) {
  const eventCoordinates = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getEventCoordinates)(event);

  if (!eventCoordinates) {
    return '0 0';
  }

  const transformOrigin = {
    x: (eventCoordinates.x - rect.left) / rect.width * 100,
    y: (eventCoordinates.y - rect.top) / rect.height * 100
  };
  return transformOrigin.x + "% " + transformOrigin.y + "%";
}

/**
 * Sort collisions from smallest to greatest value
 */
function sortCollisionsAsc(_ref, _ref2) {
  let {
    data: {
      value: a
    }
  } = _ref;
  let {
    data: {
      value: b
    }
  } = _ref2;
  return a - b;
}
/**
 * Sort collisions from greatest to smallest value
 */

function sortCollisionsDesc(_ref3, _ref4) {
  let {
    data: {
      value: a
    }
  } = _ref3;
  let {
    data: {
      value: b
    }
  } = _ref4;
  return b - a;
}
/**
 * Returns the coordinates of the corners of a given rectangle:
 * [TopLeft {x, y}, TopRight {x, y}, BottomLeft {x, y}, BottomRight {x, y}]
 */

function cornersOfRectangle(_ref5) {
  let {
    left,
    top,
    height,
    width
  } = _ref5;
  return [{
    x: left,
    y: top
  }, {
    x: left + width,
    y: top
  }, {
    x: left,
    y: top + height
  }, {
    x: left + width,
    y: top + height
  }];
}
function getFirstCollision(collisions, property) {
  if (!collisions || collisions.length === 0) {
    return null;
  }

  const [firstCollision] = collisions;
  return property ? firstCollision[property] : firstCollision;
}

/**
 * Returns the coordinates of the center of a given ClientRect
 */

function centerOfRectangle(rect, left, top) {
  if (left === void 0) {
    left = rect.left;
  }

  if (top === void 0) {
    top = rect.top;
  }

  return {
    x: left + rect.width * 0.5,
    y: top + rect.height * 0.5
  };
}
/**
 * Returns the closest rectangles from an array of rectangles to the center of a given
 * rectangle.
 */


const closestCenter = _ref => {
  let {
    collisionRect,
    droppableRects,
    droppableContainers
  } = _ref;
  const centerRect = centerOfRectangle(collisionRect, collisionRect.left, collisionRect.top);
  const collisions = [];

  for (const droppableContainer of droppableContainers) {
    const {
      id
    } = droppableContainer;
    const rect = droppableRects.get(id);

    if (rect) {
      const distBetween = distanceBetween(centerOfRectangle(rect), centerRect);
      collisions.push({
        id,
        data: {
          droppableContainer,
          value: distBetween
        }
      });
    }
  }

  return collisions.sort(sortCollisionsAsc);
};

/**
 * Returns the closest rectangles from an array of rectangles to the corners of
 * another rectangle.
 */

const closestCorners = _ref => {
  let {
    collisionRect,
    droppableRects,
    droppableContainers
  } = _ref;
  const corners = cornersOfRectangle(collisionRect);
  const collisions = [];

  for (const droppableContainer of droppableContainers) {
    const {
      id
    } = droppableContainer;
    const rect = droppableRects.get(id);

    if (rect) {
      const rectCorners = cornersOfRectangle(rect);
      const distances = corners.reduce((accumulator, corner, index) => {
        return accumulator + distanceBetween(rectCorners[index], corner);
      }, 0);
      const effectiveDistance = Number((distances / 4).toFixed(4));
      collisions.push({
        id,
        data: {
          droppableContainer,
          value: effectiveDistance
        }
      });
    }
  }

  return collisions.sort(sortCollisionsAsc);
};

/**
 * Returns the intersecting rectangle area between two rectangles
 */

function getIntersectionRatio(entry, target) {
  const top = Math.max(target.top, entry.top);
  const left = Math.max(target.left, entry.left);
  const right = Math.min(target.left + target.width, entry.left + entry.width);
  const bottom = Math.min(target.top + target.height, entry.top + entry.height);
  const width = right - left;
  const height = bottom - top;

  if (left < right && top < bottom) {
    const targetArea = target.width * target.height;
    const entryArea = entry.width * entry.height;
    const intersectionArea = width * height;
    const intersectionRatio = intersectionArea / (targetArea + entryArea - intersectionArea);
    return Number(intersectionRatio.toFixed(4));
  } // Rectangles do not overlap, or overlap has an area of zero (edge/corner overlap)


  return 0;
}
/**
 * Returns the rectangles that has the greatest intersection area with a given
 * rectangle in an array of rectangles.
 */

const rectIntersection = _ref => {
  let {
    collisionRect,
    droppableRects,
    droppableContainers
  } = _ref;
  const collisions = [];

  for (const droppableContainer of droppableContainers) {
    const {
      id
    } = droppableContainer;
    const rect = droppableRects.get(id);

    if (rect) {
      const intersectionRatio = getIntersectionRatio(rect, collisionRect);

      if (intersectionRatio > 0) {
        collisions.push({
          id,
          data: {
            droppableContainer,
            value: intersectionRatio
          }
        });
      }
    }
  }

  return collisions.sort(sortCollisionsDesc);
};

/**
 * Check if a given point is contained within a bounding rectangle
 */

function isPointWithinRect(point, rect) {
  const {
    top,
    left,
    bottom,
    right
  } = rect;
  return top <= point.y && point.y <= bottom && left <= point.x && point.x <= right;
}
/**
 * Returns the rectangles that the pointer is hovering over
 */


const pointerWithin = _ref => {
  let {
    droppableContainers,
    droppableRects,
    pointerCoordinates
  } = _ref;

  if (!pointerCoordinates) {
    return [];
  }

  const collisions = [];

  for (const droppableContainer of droppableContainers) {
    const {
      id
    } = droppableContainer;
    const rect = droppableRects.get(id);

    if (rect && isPointWithinRect(pointerCoordinates, rect)) {
      /* There may be more than a single rectangle intersecting
       * with the pointer coordinates. In order to sort the
       * colliding rectangles, we measure the distance between
       * the pointer and the corners of the intersecting rectangle
       */
      const corners = cornersOfRectangle(rect);
      const distances = corners.reduce((accumulator, corner) => {
        return accumulator + distanceBetween(pointerCoordinates, corner);
      }, 0);
      const effectiveDistance = Number((distances / 4).toFixed(4));
      collisions.push({
        id,
        data: {
          droppableContainer,
          value: effectiveDistance
        }
      });
    }
  }

  return collisions.sort(sortCollisionsAsc);
};

function adjustScale(transform, rect1, rect2) {
  return { ...transform,
    scaleX: rect1 && rect2 ? rect1.width / rect2.width : 1,
    scaleY: rect1 && rect2 ? rect1.height / rect2.height : 1
  };
}

function getRectDelta(rect1, rect2) {
  return rect1 && rect2 ? {
    x: rect1.left - rect2.left,
    y: rect1.top - rect2.top
  } : defaultCoordinates;
}

function createRectAdjustmentFn(modifier) {
  return function adjustClientRect(rect) {
    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      adjustments[_key - 1] = arguments[_key];
    }

    return adjustments.reduce((acc, adjustment) => ({ ...acc,
      top: acc.top + modifier * adjustment.y,
      bottom: acc.bottom + modifier * adjustment.y,
      left: acc.left + modifier * adjustment.x,
      right: acc.right + modifier * adjustment.x
    }), { ...rect
    });
  };
}
const getAdjustedRect = /*#__PURE__*/createRectAdjustmentFn(1);

function parseTransform(transform) {
  if (transform.startsWith('matrix3d(')) {
    const transformArray = transform.slice(9, -1).split(/, /);
    return {
      x: +transformArray[12],
      y: +transformArray[13],
      scaleX: +transformArray[0],
      scaleY: +transformArray[5]
    };
  } else if (transform.startsWith('matrix(')) {
    const transformArray = transform.slice(7, -1).split(/, /);
    return {
      x: +transformArray[4],
      y: +transformArray[5],
      scaleX: +transformArray[0],
      scaleY: +transformArray[3]
    };
  }

  return null;
}

function inverseTransform(rect, transform, transformOrigin) {
  const parsedTransform = parseTransform(transform);

  if (!parsedTransform) {
    return rect;
  }

  const {
    scaleX,
    scaleY,
    x: translateX,
    y: translateY
  } = parsedTransform;
  const x = rect.left - translateX - (1 - scaleX) * parseFloat(transformOrigin);
  const y = rect.top - translateY - (1 - scaleY) * parseFloat(transformOrigin.slice(transformOrigin.indexOf(' ') + 1));
  const w = scaleX ? rect.width / scaleX : rect.width;
  const h = scaleY ? rect.height / scaleY : rect.height;
  return {
    width: w,
    height: h,
    top: y,
    right: x + w,
    bottom: y + h,
    left: x
  };
}

const defaultOptions = {
  ignoreTransform: false
};
/**
 * Returns the bounding client rect of an element relative to the viewport.
 */

function getClientRect(element, options) {
  if (options === void 0) {
    options = defaultOptions;
  }

  let rect = element.getBoundingClientRect();

  if (options.ignoreTransform) {
    const {
      transform,
      transformOrigin
    } = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(element).getComputedStyle(element);

    if (transform) {
      rect = inverseTransform(rect, transform, transformOrigin);
    }
  }

  const {
    top,
    left,
    width,
    height,
    bottom,
    right
  } = rect;
  return {
    top,
    left,
    width,
    height,
    bottom,
    right
  };
}
/**
 * Returns the bounding client rect of an element relative to the viewport.
 *
 * @remarks
 * The ClientRect returned by this method does not take into account transforms
 * applied to the element it measures.
 *
 */

function getTransformAgnosticClientRect(element) {
  return getClientRect(element, {
    ignoreTransform: true
  });
}

function getWindowClientRect(element) {
  const width = element.innerWidth;
  const height = element.innerHeight;
  return {
    top: 0,
    left: 0,
    right: width,
    bottom: height,
    width,
    height
  };
}

function isFixed(node, computedStyle) {
  if (computedStyle === void 0) {
    computedStyle = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(node).getComputedStyle(node);
  }

  return computedStyle.position === 'fixed';
}

function isScrollable(element, computedStyle) {
  if (computedStyle === void 0) {
    computedStyle = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(element).getComputedStyle(element);
  }

  const overflowRegex = /(auto|scroll|overlay)/;
  const properties = ['overflow', 'overflowX', 'overflowY'];
  return properties.some(property => {
    const value = computedStyle[property];
    return typeof value === 'string' ? overflowRegex.test(value) : false;
  });
}

function getScrollableAncestors(element, limit) {
  const scrollParents = [];

  function findScrollableAncestors(node) {
    if (limit != null && scrollParents.length >= limit) {
      return scrollParents;
    }

    if (!node) {
      return scrollParents;
    }

    if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isDocument)(node) && node.scrollingElement != null && !scrollParents.includes(node.scrollingElement)) {
      scrollParents.push(node.scrollingElement);
      return scrollParents;
    }

    if (!(0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isHTMLElement)(node) || (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isSVGElement)(node)) {
      return scrollParents;
    }

    if (scrollParents.includes(node)) {
      return scrollParents;
    }

    const computedStyle = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(element).getComputedStyle(node);

    if (node !== element) {
      if (isScrollable(node, computedStyle)) {
        scrollParents.push(node);
      }
    }

    if (isFixed(node, computedStyle)) {
      return scrollParents;
    }

    return findScrollableAncestors(node.parentNode);
  }

  if (!element) {
    return scrollParents;
  }

  return findScrollableAncestors(element);
}
function getFirstScrollableAncestor(node) {
  const [firstScrollableAncestor] = getScrollableAncestors(node, 1);
  return firstScrollableAncestor != null ? firstScrollableAncestor : null;
}

function getScrollableElement(element) {
  if (!_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.canUseDOM || !element) {
    return null;
  }

  if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isWindow)(element)) {
    return element;
  }

  if (!(0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isNode)(element)) {
    return null;
  }

  if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isDocument)(element) || element === (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(element).scrollingElement) {
    return window;
  }

  if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isHTMLElement)(element)) {
    return element;
  }

  return null;
}

function getScrollXCoordinate(element) {
  if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isWindow)(element)) {
    return element.scrollX;
  }

  return element.scrollLeft;
}
function getScrollYCoordinate(element) {
  if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isWindow)(element)) {
    return element.scrollY;
  }

  return element.scrollTop;
}
function getScrollCoordinates(element) {
  return {
    x: getScrollXCoordinate(element),
    y: getScrollYCoordinate(element)
  };
}

var Direction;

(function (Direction) {
  Direction[Direction["Forward"] = 1] = "Forward";
  Direction[Direction["Backward"] = -1] = "Backward";
})(Direction || (Direction = {}));

function isDocumentScrollingElement(element) {
  if (!_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.canUseDOM || !element) {
    return false;
  }

  return element === document.scrollingElement;
}

function getScrollPosition(scrollingContainer) {
  const minScroll = {
    x: 0,
    y: 0
  };
  const dimensions = isDocumentScrollingElement(scrollingContainer) ? {
    height: window.innerHeight,
    width: window.innerWidth
  } : {
    height: scrollingContainer.clientHeight,
    width: scrollingContainer.clientWidth
  };
  const maxScroll = {
    x: scrollingContainer.scrollWidth - dimensions.width,
    y: scrollingContainer.scrollHeight - dimensions.height
  };
  const isTop = scrollingContainer.scrollTop <= minScroll.y;
  const isLeft = scrollingContainer.scrollLeft <= minScroll.x;
  const isBottom = scrollingContainer.scrollTop >= maxScroll.y;
  const isRight = scrollingContainer.scrollLeft >= maxScroll.x;
  return {
    isTop,
    isLeft,
    isBottom,
    isRight,
    maxScroll,
    minScroll
  };
}

const defaultThreshold = {
  x: 0.2,
  y: 0.2
};
function getScrollDirectionAndSpeed(scrollContainer, scrollContainerRect, _ref, acceleration, thresholdPercentage) {
  let {
    top,
    left,
    right,
    bottom
  } = _ref;

  if (acceleration === void 0) {
    acceleration = 10;
  }

  if (thresholdPercentage === void 0) {
    thresholdPercentage = defaultThreshold;
  }

  const {
    isTop,
    isBottom,
    isLeft,
    isRight
  } = getScrollPosition(scrollContainer);
  const direction = {
    x: 0,
    y: 0
  };
  const speed = {
    x: 0,
    y: 0
  };
  const threshold = {
    height: scrollContainerRect.height * thresholdPercentage.y,
    width: scrollContainerRect.width * thresholdPercentage.x
  };

  if (!isTop && top <= scrollContainerRect.top + threshold.height) {
    // Scroll Up
    direction.y = Direction.Backward;
    speed.y = acceleration * Math.abs((scrollContainerRect.top + threshold.height - top) / threshold.height);
  } else if (!isBottom && bottom >= scrollContainerRect.bottom - threshold.height) {
    // Scroll Down
    direction.y = Direction.Forward;
    speed.y = acceleration * Math.abs((scrollContainerRect.bottom - threshold.height - bottom) / threshold.height);
  }

  if (!isRight && right >= scrollContainerRect.right - threshold.width) {
    // Scroll Right
    direction.x = Direction.Forward;
    speed.x = acceleration * Math.abs((scrollContainerRect.right - threshold.width - right) / threshold.width);
  } else if (!isLeft && left <= scrollContainerRect.left + threshold.width) {
    // Scroll Left
    direction.x = Direction.Backward;
    speed.x = acceleration * Math.abs((scrollContainerRect.left + threshold.width - left) / threshold.width);
  }

  return {
    direction,
    speed
  };
}

function getScrollElementRect(element) {
  if (element === document.scrollingElement) {
    const {
      innerWidth,
      innerHeight
    } = window;
    return {
      top: 0,
      left: 0,
      right: innerWidth,
      bottom: innerHeight,
      width: innerWidth,
      height: innerHeight
    };
  }

  const {
    top,
    left,
    right,
    bottom
  } = element.getBoundingClientRect();
  return {
    top,
    left,
    right,
    bottom,
    width: element.clientWidth,
    height: element.clientHeight
  };
}

function getScrollOffsets(scrollableAncestors) {
  return scrollableAncestors.reduce((acc, node) => {
    return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)(acc, getScrollCoordinates(node));
  }, defaultCoordinates);
}
function getScrollXOffset(scrollableAncestors) {
  return scrollableAncestors.reduce((acc, node) => {
    return acc + getScrollXCoordinate(node);
  }, 0);
}
function getScrollYOffset(scrollableAncestors) {
  return scrollableAncestors.reduce((acc, node) => {
    return acc + getScrollYCoordinate(node);
  }, 0);
}

function scrollIntoViewIfNeeded(element, measure) {
  if (measure === void 0) {
    measure = getClientRect;
  }

  if (!element) {
    return;
  }

  const {
    top,
    left,
    bottom,
    right
  } = measure(element);
  const firstScrollableAncestor = getFirstScrollableAncestor(element);

  if (!firstScrollableAncestor) {
    return;
  }

  if (bottom <= 0 || right <= 0 || top >= window.innerHeight || left >= window.innerWidth) {
    element.scrollIntoView({
      block: 'center',
      inline: 'center'
    });
  }
}

const properties = [['x', ['left', 'right'], getScrollXOffset], ['y', ['top', 'bottom'], getScrollYOffset]];
class Rect {
  constructor(rect, element) {
    this.rect = void 0;
    this.width = void 0;
    this.height = void 0;
    this.top = void 0;
    this.bottom = void 0;
    this.right = void 0;
    this.left = void 0;
    const scrollableAncestors = getScrollableAncestors(element);
    const scrollOffsets = getScrollOffsets(scrollableAncestors);
    this.rect = { ...rect
    };
    this.width = rect.width;
    this.height = rect.height;

    for (const [axis, keys, getScrollOffset] of properties) {
      for (const key of keys) {
        Object.defineProperty(this, key, {
          get: () => {
            const currentOffsets = getScrollOffset(scrollableAncestors);
            const scrollOffsetsDeltla = scrollOffsets[axis] - currentOffsets;
            return this.rect[key] + scrollOffsetsDeltla;
          },
          enumerable: true
        });
      }
    }

    Object.defineProperty(this, 'rect', {
      enumerable: false
    });
  }

}

class Listeners {
  constructor(target) {
    this.target = void 0;
    this.listeners = [];

    this.removeAll = () => {
      this.listeners.forEach(listener => {
        var _this$target;

        return (_this$target = this.target) == null ? void 0 : _this$target.removeEventListener(...listener);
      });
    };

    this.target = target;
  }

  add(eventName, handler, options) {
    var _this$target2;

    (_this$target2 = this.target) == null ? void 0 : _this$target2.addEventListener(eventName, handler, options);
    this.listeners.push([eventName, handler, options]);
  }

}

function getEventListenerTarget(target) {
  // If the `event.target` element is removed from the document events will still be targeted
  // at it, and hence won't always bubble up to the window or document anymore.
  // If there is any risk of an element being removed while it is being dragged,
  // the best practice is to attach the event listeners directly to the target.
  // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget
  const {
    EventTarget
  } = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(target);
  return target instanceof EventTarget ? target : (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(target);
}

function hasExceededDistance(delta, measurement) {
  const dx = Math.abs(delta.x);
  const dy = Math.abs(delta.y);

  if (typeof measurement === 'number') {
    return Math.sqrt(dx ** 2 + dy ** 2) > measurement;
  }

  if ('x' in measurement && 'y' in measurement) {
    return dx > measurement.x && dy > measurement.y;
  }

  if ('x' in measurement) {
    return dx > measurement.x;
  }

  if ('y' in measurement) {
    return dy > measurement.y;
  }

  return false;
}

var EventName;

(function (EventName) {
  EventName["Click"] = "click";
  EventName["DragStart"] = "dragstart";
  EventName["Keydown"] = "keydown";
  EventName["ContextMenu"] = "contextmenu";
  EventName["Resize"] = "resize";
  EventName["SelectionChange"] = "selectionchange";
  EventName["VisibilityChange"] = "visibilitychange";
})(EventName || (EventName = {}));

function preventDefault(event) {
  event.preventDefault();
}
function stopPropagation(event) {
  event.stopPropagation();
}

var KeyboardCode;

(function (KeyboardCode) {
  KeyboardCode["Space"] = "Space";
  KeyboardCode["Down"] = "ArrowDown";
  KeyboardCode["Right"] = "ArrowRight";
  KeyboardCode["Left"] = "ArrowLeft";
  KeyboardCode["Up"] = "ArrowUp";
  KeyboardCode["Esc"] = "Escape";
  KeyboardCode["Enter"] = "Enter";
  KeyboardCode["Tab"] = "Tab";
})(KeyboardCode || (KeyboardCode = {}));

const defaultKeyboardCodes = {
  start: [KeyboardCode.Space, KeyboardCode.Enter],
  cancel: [KeyboardCode.Esc],
  end: [KeyboardCode.Space, KeyboardCode.Enter, KeyboardCode.Tab]
};
const defaultKeyboardCoordinateGetter = (event, _ref) => {
  let {
    currentCoordinates
  } = _ref;

  switch (event.code) {
    case KeyboardCode.Right:
      return { ...currentCoordinates,
        x: currentCoordinates.x + 25
      };

    case KeyboardCode.Left:
      return { ...currentCoordinates,
        x: currentCoordinates.x - 25
      };

    case KeyboardCode.Down:
      return { ...currentCoordinates,
        y: currentCoordinates.y + 25
      };

    case KeyboardCode.Up:
      return { ...currentCoordinates,
        y: currentCoordinates.y - 25
      };
  }

  return undefined;
};

class KeyboardSensor {
  constructor(props) {
    this.props = void 0;
    this.autoScrollEnabled = false;
    this.referenceCoordinates = void 0;
    this.listeners = void 0;
    this.windowListeners = void 0;
    this.props = props;
    const {
      event: {
        target
      }
    } = props;
    this.props = props;
    this.listeners = new Listeners((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(target));
    this.windowListeners = new Listeners((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(target));
    this.handleKeyDown = this.handleKeyDown.bind(this);
    this.handleCancel = this.handleCancel.bind(this);
    this.attach();
  }

  attach() {
    this.handleStart();
    this.windowListeners.add(EventName.Resize, this.handleCancel);
    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);
    setTimeout(() => this.listeners.add(EventName.Keydown, this.handleKeyDown));
  }

  handleStart() {
    const {
      activeNode,
      onStart
    } = this.props;
    const node = activeNode.node.current;

    if (node) {
      scrollIntoViewIfNeeded(node);
    }

    onStart(defaultCoordinates);
  }

  handleKeyDown(event) {
    if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isKeyboardEvent)(event)) {
      const {
        active,
        context,
        options
      } = this.props;
      const {
        keyboardCodes = defaultKeyboardCodes,
        coordinateGetter = defaultKeyboardCoordinateGetter,
        scrollBehavior = 'smooth'
      } = options;
      const {
        code
      } = event;

      if (keyboardCodes.end.includes(code)) {
        this.handleEnd(event);
        return;
      }

      if (keyboardCodes.cancel.includes(code)) {
        this.handleCancel(event);
        return;
      }

      const {
        collisionRect
      } = context.current;
      const currentCoordinates = collisionRect ? {
        x: collisionRect.left,
        y: collisionRect.top
      } : defaultCoordinates;

      if (!this.referenceCoordinates) {
        this.referenceCoordinates = currentCoordinates;
      }

      const newCoordinates = coordinateGetter(event, {
        active,
        context: context.current,
        currentCoordinates
      });

      if (newCoordinates) {
        const coordinatesDelta = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.subtract)(newCoordinates, currentCoordinates);
        const scrollDelta = {
          x: 0,
          y: 0
        };
        const {
          scrollableAncestors
        } = context.current;

        for (const scrollContainer of scrollableAncestors) {
          const direction = event.code;
          const {
            isTop,
            isRight,
            isLeft,
            isBottom,
            maxScroll,
            minScroll
          } = getScrollPosition(scrollContainer);
          const scrollElementRect = getScrollElementRect(scrollContainer);
          const clampedCoordinates = {
            x: Math.min(direction === KeyboardCode.Right ? scrollElementRect.right - scrollElementRect.width / 2 : scrollElementRect.right, Math.max(direction === KeyboardCode.Right ? scrollElementRect.left : scrollElementRect.left + scrollElementRect.width / 2, newCoordinates.x)),
            y: Math.min(direction === KeyboardCode.Down ? scrollElementRect.bottom - scrollElementRect.height / 2 : scrollElementRect.bottom, Math.max(direction === KeyboardCode.Down ? scrollElementRect.top : scrollElementRect.top + scrollElementRect.height / 2, newCoordinates.y))
          };
          const canScrollX = direction === KeyboardCode.Right && !isRight || direction === KeyboardCode.Left && !isLeft;
          const canScrollY = direction === KeyboardCode.Down && !isBottom || direction === KeyboardCode.Up && !isTop;

          if (canScrollX && clampedCoordinates.x !== newCoordinates.x) {
            const newScrollCoordinates = scrollContainer.scrollLeft + coordinatesDelta.x;
            const canScrollToNewCoordinates = direction === KeyboardCode.Right && newScrollCoordinates <= maxScroll.x || direction === KeyboardCode.Left && newScrollCoordinates >= minScroll.x;

            if (canScrollToNewCoordinates && !coordinatesDelta.y) {
              // We don't need to update coordinates, the scroll adjustment alone will trigger
              // logic to auto-detect the new container we are over
              scrollContainer.scrollTo({
                left: newScrollCoordinates,
                behavior: scrollBehavior
              });
              return;
            }

            if (canScrollToNewCoordinates) {
              scrollDelta.x = scrollContainer.scrollLeft - newScrollCoordinates;
            } else {
              scrollDelta.x = direction === KeyboardCode.Right ? scrollContainer.scrollLeft - maxScroll.x : scrollContainer.scrollLeft - minScroll.x;
            }

            if (scrollDelta.x) {
              scrollContainer.scrollBy({
                left: -scrollDelta.x,
                behavior: scrollBehavior
              });
            }

            break;
          } else if (canScrollY && clampedCoordinates.y !== newCoordinates.y) {
            const newScrollCoordinates = scrollContainer.scrollTop + coordinatesDelta.y;
            const canScrollToNewCoordinates = direction === KeyboardCode.Down && newScrollCoordinates <= maxScroll.y || direction === KeyboardCode.Up && newScrollCoordinates >= minScroll.y;

            if (canScrollToNewCoordinates && !coordinatesDelta.x) {
              // We don't need to update coordinates, the scroll adjustment alone will trigger
              // logic to auto-detect the new container we are over
              scrollContainer.scrollTo({
                top: newScrollCoordinates,
                behavior: scrollBehavior
              });
              return;
            }

            if (canScrollToNewCoordinates) {
              scrollDelta.y = scrollContainer.scrollTop - newScrollCoordinates;
            } else {
              scrollDelta.y = direction === KeyboardCode.Down ? scrollContainer.scrollTop - maxScroll.y : scrollContainer.scrollTop - minScroll.y;
            }

            if (scrollDelta.y) {
              scrollContainer.scrollBy({
                top: -scrollDelta.y,
                behavior: scrollBehavior
              });
            }

            break;
          }
        }

        this.handleMove(event, (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.subtract)(newCoordinates, this.referenceCoordinates), scrollDelta));
      }
    }
  }

  handleMove(event, coordinates) {
    const {
      onMove
    } = this.props;
    event.preventDefault();
    onMove(coordinates);
  }

  handleEnd(event) {
    const {
      onEnd
    } = this.props;
    event.preventDefault();
    this.detach();
    onEnd();
  }

  handleCancel(event) {
    const {
      onCancel
    } = this.props;
    event.preventDefault();
    this.detach();
    onCancel();
  }

  detach() {
    this.listeners.removeAll();
    this.windowListeners.removeAll();
  }

}
KeyboardSensor.activators = [{
  eventName: 'onKeyDown',
  handler: (event, _ref, _ref2) => {
    let {
      keyboardCodes = defaultKeyboardCodes,
      onActivation
    } = _ref;
    let {
      active
    } = _ref2;
    const {
      code
    } = event.nativeEvent;

    if (keyboardCodes.start.includes(code)) {
      const activator = active.activatorNode.current;

      if (activator && event.target !== activator) {
        return false;
      }

      event.preventDefault();
      onActivation == null ? void 0 : onActivation({
        event: event.nativeEvent
      });
      return true;
    }

    return false;
  }
}];

function isDistanceConstraint(constraint) {
  return Boolean(constraint && 'distance' in constraint);
}

function isDelayConstraint(constraint) {
  return Boolean(constraint && 'delay' in constraint);
}

class AbstractPointerSensor {
  constructor(props, events, listenerTarget) {
    var _getEventCoordinates;

    if (listenerTarget === void 0) {
      listenerTarget = getEventListenerTarget(props.event.target);
    }

    this.props = void 0;
    this.events = void 0;
    this.autoScrollEnabled = true;
    this.document = void 0;
    this.activated = false;
    this.initialCoordinates = void 0;
    this.timeoutId = null;
    this.listeners = void 0;
    this.documentListeners = void 0;
    this.windowListeners = void 0;
    this.props = props;
    this.events = events;
    const {
      event
    } = props;
    const {
      target
    } = event;
    this.props = props;
    this.events = events;
    this.document = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(target);
    this.documentListeners = new Listeners(this.document);
    this.listeners = new Listeners(listenerTarget);
    this.windowListeners = new Listeners((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(target));
    this.initialCoordinates = (_getEventCoordinates = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getEventCoordinates)(event)) != null ? _getEventCoordinates : defaultCoordinates;
    this.handleStart = this.handleStart.bind(this);
    this.handleMove = this.handleMove.bind(this);
    this.handleEnd = this.handleEnd.bind(this);
    this.handleCancel = this.handleCancel.bind(this);
    this.handleKeydown = this.handleKeydown.bind(this);
    this.removeTextSelection = this.removeTextSelection.bind(this);
    this.attach();
  }

  attach() {
    const {
      events,
      props: {
        options: {
          activationConstraint,
          bypassActivationConstraint
        }
      }
    } = this;
    this.listeners.add(events.move.name, this.handleMove, {
      passive: false
    });
    this.listeners.add(events.end.name, this.handleEnd);

    if (events.cancel) {
      this.listeners.add(events.cancel.name, this.handleCancel);
    }

    this.windowListeners.add(EventName.Resize, this.handleCancel);
    this.windowListeners.add(EventName.DragStart, preventDefault);
    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);
    this.windowListeners.add(EventName.ContextMenu, preventDefault);
    this.documentListeners.add(EventName.Keydown, this.handleKeydown);

    if (activationConstraint) {
      if (bypassActivationConstraint != null && bypassActivationConstraint({
        event: this.props.event,
        activeNode: this.props.activeNode,
        options: this.props.options
      })) {
        return this.handleStart();
      }

      if (isDelayConstraint(activationConstraint)) {
        this.timeoutId = setTimeout(this.handleStart, activationConstraint.delay);
        this.handlePending(activationConstraint);
        return;
      }

      if (isDistanceConstraint(activationConstraint)) {
        this.handlePending(activationConstraint);
        return;
      }
    }

    this.handleStart();
  }

  detach() {
    this.listeners.removeAll();
    this.windowListeners.removeAll(); // Wait until the next event loop before removing document listeners
    // This is necessary because we listen for `click` and `selection` events on the document

    setTimeout(this.documentListeners.removeAll, 50);

    if (this.timeoutId !== null) {
      clearTimeout(this.timeoutId);
      this.timeoutId = null;
    }
  }

  handlePending(constraint, offset) {
    const {
      active,
      onPending
    } = this.props;
    onPending(active, constraint, this.initialCoordinates, offset);
  }

  handleStart() {
    const {
      initialCoordinates
    } = this;
    const {
      onStart
    } = this.props;

    if (initialCoordinates) {
      this.activated = true; // Stop propagation of click events once activation constraints are met

      this.documentListeners.add(EventName.Click, stopPropagation, {
        capture: true
      }); // Remove any text selection from the document

      this.removeTextSelection(); // Prevent further text selection while dragging

      this.documentListeners.add(EventName.SelectionChange, this.removeTextSelection);
      onStart(initialCoordinates);
    }
  }

  handleMove(event) {
    var _getEventCoordinates2;

    const {
      activated,
      initialCoordinates,
      props
    } = this;
    const {
      onMove,
      options: {
        activationConstraint
      }
    } = props;

    if (!initialCoordinates) {
      return;
    }

    const coordinates = (_getEventCoordinates2 = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getEventCoordinates)(event)) != null ? _getEventCoordinates2 : defaultCoordinates;
    const delta = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.subtract)(initialCoordinates, coordinates); // Constraint validation

    if (!activated && activationConstraint) {
      if (isDistanceConstraint(activationConstraint)) {
        if (activationConstraint.tolerance != null && hasExceededDistance(delta, activationConstraint.tolerance)) {
          return this.handleCancel();
        }

        if (hasExceededDistance(delta, activationConstraint.distance)) {
          return this.handleStart();
        }
      }

      if (isDelayConstraint(activationConstraint)) {
        if (hasExceededDistance(delta, activationConstraint.tolerance)) {
          return this.handleCancel();
        }
      }

      this.handlePending(activationConstraint, delta);
      return;
    }

    if (event.cancelable) {
      event.preventDefault();
    }

    onMove(coordinates);
  }

  handleEnd() {
    const {
      onAbort,
      onEnd
    } = this.props;
    this.detach();

    if (!this.activated) {
      onAbort(this.props.active);
    }

    onEnd();
  }

  handleCancel() {
    const {
      onAbort,
      onCancel
    } = this.props;
    this.detach();

    if (!this.activated) {
      onAbort(this.props.active);
    }

    onCancel();
  }

  handleKeydown(event) {
    if (event.code === KeyboardCode.Esc) {
      this.handleCancel();
    }
  }

  removeTextSelection() {
    var _this$document$getSel;

    (_this$document$getSel = this.document.getSelection()) == null ? void 0 : _this$document$getSel.removeAllRanges();
  }

}

const events = {
  cancel: {
    name: 'pointercancel'
  },
  move: {
    name: 'pointermove'
  },
  end: {
    name: 'pointerup'
  }
};
class PointerSensor extends AbstractPointerSensor {
  constructor(props) {
    const {
      event
    } = props; // Pointer events stop firing if the target is unmounted while dragging
    // Therefore we attach listeners to the owner document instead

    const listenerTarget = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(event.target);
    super(props, events, listenerTarget);
  }

}
PointerSensor.activators = [{
  eventName: 'onPointerDown',
  handler: (_ref, _ref2) => {
    let {
      nativeEvent: event
    } = _ref;
    let {
      onActivation
    } = _ref2;

    if (!event.isPrimary || event.button !== 0) {
      return false;
    }

    onActivation == null ? void 0 : onActivation({
      event
    });
    return true;
  }
}];

const events$1 = {
  move: {
    name: 'mousemove'
  },
  end: {
    name: 'mouseup'
  }
};
var MouseButton;

(function (MouseButton) {
  MouseButton[MouseButton["RightClick"] = 2] = "RightClick";
})(MouseButton || (MouseButton = {}));

class MouseSensor extends AbstractPointerSensor {
  constructor(props) {
    super(props, events$1, (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getOwnerDocument)(props.event.target));
  }

}
MouseSensor.activators = [{
  eventName: 'onMouseDown',
  handler: (_ref, _ref2) => {
    let {
      nativeEvent: event
    } = _ref;
    let {
      onActivation
    } = _ref2;

    if (event.button === MouseButton.RightClick) {
      return false;
    }

    onActivation == null ? void 0 : onActivation({
      event
    });
    return true;
  }
}];

const events$2 = {
  cancel: {
    name: 'touchcancel'
  },
  move: {
    name: 'touchmove'
  },
  end: {
    name: 'touchend'
  }
};
class TouchSensor extends AbstractPointerSensor {
  constructor(props) {
    super(props, events$2);
  }

  static setup() {
    // Adding a non-capture and non-passive `touchmove` listener in order
    // to force `event.preventDefault()` calls to work in dynamically added
    // touchmove event handlers. This is required for iOS Safari.
    window.addEventListener(events$2.move.name, noop, {
      capture: false,
      passive: false
    });
    return function teardown() {
      window.removeEventListener(events$2.move.name, noop);
    }; // We create a new handler because the teardown function of another sensor
    // could remove our event listener if we use a referentially equal listener.

    function noop() {}
  }

}
TouchSensor.activators = [{
  eventName: 'onTouchStart',
  handler: (_ref, _ref2) => {
    let {
      nativeEvent: event
    } = _ref;
    let {
      onActivation
    } = _ref2;
    const {
      touches
    } = event;

    if (touches.length > 1) {
      return false;
    }

    onActivation == null ? void 0 : onActivation({
      event
    });
    return true;
  }
}];

var AutoScrollActivator;

(function (AutoScrollActivator) {
  AutoScrollActivator[AutoScrollActivator["Pointer"] = 0] = "Pointer";
  AutoScrollActivator[AutoScrollActivator["DraggableRect"] = 1] = "DraggableRect";
})(AutoScrollActivator || (AutoScrollActivator = {}));

var TraversalOrder;

(function (TraversalOrder) {
  TraversalOrder[TraversalOrder["TreeOrder"] = 0] = "TreeOrder";
  TraversalOrder[TraversalOrder["ReversedTreeOrder"] = 1] = "ReversedTreeOrder";
})(TraversalOrder || (TraversalOrder = {}));

function useAutoScroller(_ref) {
  let {
    acceleration,
    activator = AutoScrollActivator.Pointer,
    canScroll,
    draggingRect,
    enabled,
    interval = 5,
    order = TraversalOrder.TreeOrder,
    pointerCoordinates,
    scrollableAncestors,
    scrollableAncestorRects,
    delta,
    threshold
  } = _ref;
  const scrollIntent = useScrollIntent({
    delta,
    disabled: !enabled
  });
  const [setAutoScrollInterval, clearAutoScrollInterval] = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useInterval)();
  const scrollSpeed = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    x: 0,
    y: 0
  });
  const scrollDirection = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    x: 0,
    y: 0
  });
  const rect = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    switch (activator) {
      case AutoScrollActivator.Pointer:
        return pointerCoordinates ? {
          top: pointerCoordinates.y,
          bottom: pointerCoordinates.y,
          left: pointerCoordinates.x,
          right: pointerCoordinates.x
        } : null;

      case AutoScrollActivator.DraggableRect:
        return draggingRect;
    }
  }, [activator, draggingRect, pointerCoordinates]);
  const scrollContainerRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const autoScroll = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(() => {
    const scrollContainer = scrollContainerRef.current;

    if (!scrollContainer) {
      return;
    }

    const scrollLeft = scrollSpeed.current.x * scrollDirection.current.x;
    const scrollTop = scrollSpeed.current.y * scrollDirection.current.y;
    scrollContainer.scrollBy(scrollLeft, scrollTop);
  }, []);
  const sortedScrollableAncestors = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => order === TraversalOrder.TreeOrder ? [...scrollableAncestors].reverse() : scrollableAncestors, [order, scrollableAncestors]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (!enabled || !scrollableAncestors.length || !rect) {
      clearAutoScrollInterval();
      return;
    }

    for (const scrollContainer of sortedScrollableAncestors) {
      if ((canScroll == null ? void 0 : canScroll(scrollContainer)) === false) {
        continue;
      }

      const index = scrollableAncestors.indexOf(scrollContainer);
      const scrollContainerRect = scrollableAncestorRects[index];

      if (!scrollContainerRect) {
        continue;
      }

      const {
        direction,
        speed
      } = getScrollDirectionAndSpeed(scrollContainer, scrollContainerRect, rect, acceleration, threshold);

      for (const axis of ['x', 'y']) {
        if (!scrollIntent[axis][direction[axis]]) {
          speed[axis] = 0;
          direction[axis] = 0;
        }
      }

      if (speed.x > 0 || speed.y > 0) {
        clearAutoScrollInterval();
        scrollContainerRef.current = scrollContainer;
        setAutoScrollInterval(autoScroll, interval);
        scrollSpeed.current = speed;
        scrollDirection.current = direction;
        return;
      }
    }

    scrollSpeed.current = {
      x: 0,
      y: 0
    };
    scrollDirection.current = {
      x: 0,
      y: 0
    };
    clearAutoScrollInterval();
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [acceleration, autoScroll, canScroll, clearAutoScrollInterval, enabled, interval, // eslint-disable-next-line react-hooks/exhaustive-deps
  JSON.stringify(rect), // eslint-disable-next-line react-hooks/exhaustive-deps
  JSON.stringify(scrollIntent), setAutoScrollInterval, scrollableAncestors, sortedScrollableAncestors, scrollableAncestorRects, // eslint-disable-next-line react-hooks/exhaustive-deps
  JSON.stringify(threshold)]);
}
const defaultScrollIntent = {
  x: {
    [Direction.Backward]: false,
    [Direction.Forward]: false
  },
  y: {
    [Direction.Backward]: false,
    [Direction.Forward]: false
  }
};

function useScrollIntent(_ref2) {
  let {
    delta,
    disabled
  } = _ref2;
  const previousDelta = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.usePrevious)(delta);
  return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLazyMemo)(previousIntent => {
    if (disabled || !previousDelta || !previousIntent) {
      // Reset scroll intent tracking when auto-scrolling is disabled
      return defaultScrollIntent;
    }

    const direction = {
      x: Math.sign(delta.x - previousDelta.x),
      y: Math.sign(delta.y - previousDelta.y)
    }; // Keep track of the user intent to scroll in each direction for both axis

    return {
      x: {
        [Direction.Backward]: previousIntent.x[Direction.Backward] || direction.x === -1,
        [Direction.Forward]: previousIntent.x[Direction.Forward] || direction.x === 1
      },
      y: {
        [Direction.Backward]: previousIntent.y[Direction.Backward] || direction.y === -1,
        [Direction.Forward]: previousIntent.y[Direction.Forward] || direction.y === 1
      }
    };
  }, [disabled, delta, previousDelta]);
}

function useCachedNode(draggableNodes, id) {
  const draggableNode = id != null ? draggableNodes.get(id) : undefined;
  const node = draggableNode ? draggableNode.node.current : null;
  return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLazyMemo)(cachedNode => {
    var _ref;

    if (id == null) {
      return null;
    } // In some cases, the draggable node can unmount while dragging
    // This is the case for virtualized lists. In those situations,
    // we fall back to the last known value for that node.


    return (_ref = node != null ? node : cachedNode) != null ? _ref : null;
  }, [node, id]);
}

function useCombineActivators(sensors, getSyntheticHandler) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => sensors.reduce((accumulator, sensor) => {
    const {
      sensor: Sensor
    } = sensor;
    const sensorActivators = Sensor.activators.map(activator => ({
      eventName: activator.eventName,
      handler: getSyntheticHandler(activator.handler, sensor)
    }));
    return [...accumulator, ...sensorActivators];
  }, []), [sensors, getSyntheticHandler]);
}

var MeasuringStrategy;

(function (MeasuringStrategy) {
  MeasuringStrategy[MeasuringStrategy["Always"] = 0] = "Always";
  MeasuringStrategy[MeasuringStrategy["BeforeDragging"] = 1] = "BeforeDragging";
  MeasuringStrategy[MeasuringStrategy["WhileDragging"] = 2] = "WhileDragging";
})(MeasuringStrategy || (MeasuringStrategy = {}));

var MeasuringFrequency;

(function (MeasuringFrequency) {
  MeasuringFrequency["Optimized"] = "optimized";
})(MeasuringFrequency || (MeasuringFrequency = {}));

const defaultValue = /*#__PURE__*/new Map();
function useDroppableMeasuring(containers, _ref) {
  let {
    dragging,
    dependencies,
    config
  } = _ref;
  const [queue, setQueue] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const {
    frequency,
    measure,
    strategy
  } = config;
  const containersRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(containers);
  const disabled = isDisabled();
  const disabledRef = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLatestValue)(disabled);
  const measureDroppableContainers = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(function (ids) {
    if (ids === void 0) {
      ids = [];
    }

    if (disabledRef.current) {
      return;
    }

    setQueue(value => {
      if (value === null) {
        return ids;
      }

      return value.concat(ids.filter(id => !value.includes(id)));
    });
  }, [disabledRef]);
  const timeoutId = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const droppableRects = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLazyMemo)(previousValue => {
    if (disabled && !dragging) {
      return defaultValue;
    }

    if (!previousValue || previousValue === defaultValue || containersRef.current !== containers || queue != null) {
      const map = new Map();

      for (let container of containers) {
        if (!container) {
          continue;
        }

        if (queue && queue.length > 0 && !queue.includes(container.id) && container.rect.current) {
          // This container does not need to be re-measured
          map.set(container.id, container.rect.current);
          continue;
        }

        const node = container.node.current;
        const rect = node ? new Rect(measure(node), node) : null;
        container.rect.current = rect;

        if (rect) {
          map.set(container.id, rect);
        }
      }

      return map;
    }

    return previousValue;
  }, [containers, queue, dragging, disabled, measure]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    containersRef.current = containers;
  }, [containers]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (disabled) {
      return;
    }

    measureDroppableContainers();
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [dragging, disabled]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (queue && queue.length > 0) {
      setQueue(null);
    }
  }, //eslint-disable-next-line react-hooks/exhaustive-deps
  [JSON.stringify(queue)]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (disabled || typeof frequency !== 'number' || timeoutId.current !== null) {
      return;
    }

    timeoutId.current = setTimeout(() => {
      measureDroppableContainers();
      timeoutId.current = null;
    }, frequency);
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [frequency, disabled, measureDroppableContainers, ...dependencies]);
  return {
    droppableRects,
    measureDroppableContainers,
    measuringScheduled: queue != null
  };

  function isDisabled() {
    switch (strategy) {
      case MeasuringStrategy.Always:
        return false;

      case MeasuringStrategy.BeforeDragging:
        return dragging;

      default:
        return !dragging;
    }
  }
}

function useInitialValue(value, computeFn) {
  return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLazyMemo)(previousValue => {
    if (!value) {
      return null;
    }

    if (previousValue) {
      return previousValue;
    }

    return typeof computeFn === 'function' ? computeFn(value) : value;
  }, [computeFn, value]);
}

function useInitialRect(node, measure) {
  return useInitialValue(node, measure);
}

/**
 * Returns a new MutationObserver instance.
 * If `MutationObserver` is undefined in the execution environment, returns `undefined`.
 */

function useMutationObserver(_ref) {
  let {
    callback,
    disabled
  } = _ref;
  const handleMutations = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useEvent)(callback);
  const mutationObserver = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    if (disabled || typeof window === 'undefined' || typeof window.MutationObserver === 'undefined') {
      return undefined;
    }

    const {
      MutationObserver
    } = window;
    return new MutationObserver(handleMutations);
  }, [handleMutations, disabled]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    return () => mutationObserver == null ? void 0 : mutationObserver.disconnect();
  }, [mutationObserver]);
  return mutationObserver;
}

/**
 * Returns a new ResizeObserver instance bound to the `onResize` callback.
 * If `ResizeObserver` is undefined in the execution environment, returns `undefined`.
 */

function useResizeObserver(_ref) {
  let {
    callback,
    disabled
  } = _ref;
  const handleResize = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useEvent)(callback);
  const resizeObserver = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    if (disabled || typeof window === 'undefined' || typeof window.ResizeObserver === 'undefined') {
      return undefined;
    }

    const {
      ResizeObserver
    } = window;
    return new ResizeObserver(handleResize);
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [disabled]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    return () => resizeObserver == null ? void 0 : resizeObserver.disconnect();
  }, [resizeObserver]);
  return resizeObserver;
}

function defaultMeasure(element) {
  return new Rect(getClientRect(element), element);
}

function useRect(element, measure, fallbackRect) {
  if (measure === void 0) {
    measure = defaultMeasure;
  }

  const [rect, setRect] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);

  function measureRect() {
    setRect(currentRect => {
      if (!element) {
        return null;
      }

      if (element.isConnected === false) {
        var _ref;

        // Fall back to last rect we measured if the element is
        // no longer connected to the DOM.
        return (_ref = currentRect != null ? currentRect : fallbackRect) != null ? _ref : null;
      }

      const newRect = measure(element);

      if (JSON.stringify(currentRect) === JSON.stringify(newRect)) {
        return currentRect;
      }

      return newRect;
    });
  }

  const mutationObserver = useMutationObserver({
    callback(records) {
      if (!element) {
        return;
      }

      for (const record of records) {
        const {
          type,
          target
        } = record;

        if (type === 'childList' && target instanceof HTMLElement && target.contains(element)) {
          measureRect();
          break;
        }
      }
    }

  });
  const resizeObserver = useResizeObserver({
    callback: measureRect
  });
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    measureRect();

    if (element) {
      resizeObserver == null ? void 0 : resizeObserver.observe(element);
      mutationObserver == null ? void 0 : mutationObserver.observe(document.body, {
        childList: true,
        subtree: true
      });
    } else {
      resizeObserver == null ? void 0 : resizeObserver.disconnect();
      mutationObserver == null ? void 0 : mutationObserver.disconnect();
    }
  }, [element]);
  return rect;
}

function useRectDelta(rect) {
  const initialRect = useInitialValue(rect);
  return getRectDelta(rect, initialRect);
}

const defaultValue$1 = [];
function useScrollableAncestors(node) {
  const previousNode = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(node);
  const ancestors = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLazyMemo)(previousValue => {
    if (!node) {
      return defaultValue$1;
    }

    if (previousValue && previousValue !== defaultValue$1 && node && previousNode.current && node.parentNode === previousNode.current.parentNode) {
      return previousValue;
    }

    return getScrollableAncestors(node);
  }, [node]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    previousNode.current = node;
  }, [node]);
  return ancestors;
}

function useScrollOffsets(elements) {
  const [scrollCoordinates, setScrollCoordinates] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const prevElements = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(elements); // To-do: Throttle the handleScroll callback

  const handleScroll = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(event => {
    const scrollingElement = getScrollableElement(event.target);

    if (!scrollingElement) {
      return;
    }

    setScrollCoordinates(scrollCoordinates => {
      if (!scrollCoordinates) {
        return null;
      }

      scrollCoordinates.set(scrollingElement, getScrollCoordinates(scrollingElement));
      return new Map(scrollCoordinates);
    });
  }, []);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    const previousElements = prevElements.current;

    if (elements !== previousElements) {
      cleanup(previousElements);
      const entries = elements.map(element => {
        const scrollableElement = getScrollableElement(element);

        if (scrollableElement) {
          scrollableElement.addEventListener('scroll', handleScroll, {
            passive: true
          });
          return [scrollableElement, getScrollCoordinates(scrollableElement)];
        }

        return null;
      }).filter(entry => entry != null);
      setScrollCoordinates(entries.length ? new Map(entries) : null);
      prevElements.current = elements;
    }

    return () => {
      cleanup(elements);
      cleanup(previousElements);
    };

    function cleanup(elements) {
      elements.forEach(element => {
        const scrollableElement = getScrollableElement(element);
        scrollableElement == null ? void 0 : scrollableElement.removeEventListener('scroll', handleScroll);
      });
    }
  }, [handleScroll, elements]);
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    if (elements.length) {
      return scrollCoordinates ? Array.from(scrollCoordinates.values()).reduce((acc, coordinates) => (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)(acc, coordinates), defaultCoordinates) : getScrollOffsets(elements);
    }

    return defaultCoordinates;
  }, [elements, scrollCoordinates]);
}

function useScrollOffsetsDelta(scrollOffsets, dependencies) {
  if (dependencies === void 0) {
    dependencies = [];
  }

  const initialScrollOffsets = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    initialScrollOffsets.current = null;
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  dependencies);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    const hasScrollOffsets = scrollOffsets !== defaultCoordinates;

    if (hasScrollOffsets && !initialScrollOffsets.current) {
      initialScrollOffsets.current = scrollOffsets;
    }

    if (!hasScrollOffsets && initialScrollOffsets.current) {
      initialScrollOffsets.current = null;
    }
  }, [scrollOffsets]);
  return initialScrollOffsets.current ? (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.subtract)(scrollOffsets, initialScrollOffsets.current) : defaultCoordinates;
}

function useSensorSetup(sensors) {
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (!_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.canUseDOM) {
      return;
    }

    const teardownFns = sensors.map(_ref => {
      let {
        sensor
      } = _ref;
      return sensor.setup == null ? void 0 : sensor.setup();
    });
    return () => {
      for (const teardown of teardownFns) {
        teardown == null ? void 0 : teardown();
      }
    };
  }, // TO-DO: Sensors length could theoretically change which would not be a valid dependency
  // eslint-disable-next-line react-hooks/exhaustive-deps
  sensors.map(_ref2 => {
    let {
      sensor
    } = _ref2;
    return sensor;
  }));
}

function useSyntheticListeners(listeners, id) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    return listeners.reduce((acc, _ref) => {
      let {
        eventName,
        handler
      } = _ref;

      acc[eventName] = event => {
        handler(event, id);
      };

      return acc;
    }, {});
  }, [listeners, id]);
}

function useWindowRect(element) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => element ? getWindowClientRect(element) : null, [element]);
}

const defaultValue$2 = [];
function useRects(elements, measure) {
  if (measure === void 0) {
    measure = getClientRect;
  }

  const [firstElement] = elements;
  const windowRect = useWindowRect(firstElement ? (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(firstElement) : null);
  const [rects, setRects] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(defaultValue$2);

  function measureRects() {
    setRects(() => {
      if (!elements.length) {
        return defaultValue$2;
      }

      return elements.map(element => isDocumentScrollingElement(element) ? windowRect : new Rect(measure(element), element));
    });
  }

  const resizeObserver = useResizeObserver({
    callback: measureRects
  });
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    resizeObserver == null ? void 0 : resizeObserver.disconnect();
    measureRects();
    elements.forEach(element => resizeObserver == null ? void 0 : resizeObserver.observe(element));
  }, [elements]);
  return rects;
}

function getMeasurableNode(node) {
  if (!node) {
    return null;
  }

  if (node.children.length > 1) {
    return node;
  }

  const firstChild = node.children[0];
  return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isHTMLElement)(firstChild) ? firstChild : node;
}

function useDragOverlayMeasuring(_ref) {
  let {
    measure
  } = _ref;
  const [rect, setRect] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const handleResize = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(entries => {
    for (const {
      target
    } of entries) {
      if ((0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isHTMLElement)(target)) {
        setRect(rect => {
          const newRect = measure(target);
          return rect ? { ...rect,
            width: newRect.width,
            height: newRect.height
          } : newRect;
        });
        break;
      }
    }
  }, [measure]);
  const resizeObserver = useResizeObserver({
    callback: handleResize
  });
  const handleNodeChange = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(element => {
    const node = getMeasurableNode(element);
    resizeObserver == null ? void 0 : resizeObserver.disconnect();

    if (node) {
      resizeObserver == null ? void 0 : resizeObserver.observe(node);
    }

    setRect(node ? measure(node) : null);
  }, [measure, resizeObserver]);
  const [nodeRef, setRef] = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useNodeRef)(handleNodeChange);
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    nodeRef,
    rect,
    setRef
  }), [rect, nodeRef, setRef]);
}

const defaultSensors = [{
  sensor: PointerSensor,
  options: {}
}, {
  sensor: KeyboardSensor,
  options: {}
}];
const defaultData = {
  current: {}
};
const defaultMeasuringConfiguration = {
  draggable: {
    measure: getTransformAgnosticClientRect
  },
  droppable: {
    measure: getTransformAgnosticClientRect,
    strategy: MeasuringStrategy.WhileDragging,
    frequency: MeasuringFrequency.Optimized
  },
  dragOverlay: {
    measure: getClientRect
  }
};

class DroppableContainersMap extends Map {
  get(id) {
    var _super$get;

    return id != null ? (_super$get = super.get(id)) != null ? _super$get : undefined : undefined;
  }

  toArray() {
    return Array.from(this.values());
  }

  getEnabled() {
    return this.toArray().filter(_ref => {
      let {
        disabled
      } = _ref;
      return !disabled;
    });
  }

  getNodeFor(id) {
    var _this$get$node$curren, _this$get;

    return (_this$get$node$curren = (_this$get = this.get(id)) == null ? void 0 : _this$get.node.current) != null ? _this$get$node$curren : undefined;
  }

}

const defaultPublicContext = {
  activatorEvent: null,
  active: null,
  activeNode: null,
  activeNodeRect: null,
  collisions: null,
  containerNodeRect: null,
  draggableNodes: /*#__PURE__*/new Map(),
  droppableRects: /*#__PURE__*/new Map(),
  droppableContainers: /*#__PURE__*/new DroppableContainersMap(),
  over: null,
  dragOverlay: {
    nodeRef: {
      current: null
    },
    rect: null,
    setRef: noop
  },
  scrollableAncestors: [],
  scrollableAncestorRects: [],
  measuringConfiguration: defaultMeasuringConfiguration,
  measureDroppableContainers: noop,
  windowRect: null,
  measuringScheduled: false
};
const defaultInternalContext = {
  activatorEvent: null,
  activators: [],
  active: null,
  activeNodeRect: null,
  ariaDescribedById: {
    draggable: ''
  },
  dispatch: noop,
  draggableNodes: /*#__PURE__*/new Map(),
  over: null,
  measureDroppableContainers: noop
};
const InternalContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(defaultInternalContext);
const PublicContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(defaultPublicContext);

function getInitialState() {
  return {
    draggable: {
      active: null,
      initialCoordinates: {
        x: 0,
        y: 0
      },
      nodes: new Map(),
      translate: {
        x: 0,
        y: 0
      }
    },
    droppable: {
      containers: new DroppableContainersMap()
    }
  };
}
function reducer(state, action) {
  switch (action.type) {
    case Action.DragStart:
      return { ...state,
        draggable: { ...state.draggable,
          initialCoordinates: action.initialCoordinates,
          active: action.active
        }
      };

    case Action.DragMove:
      if (state.draggable.active == null) {
        return state;
      }

      return { ...state,
        draggable: { ...state.draggable,
          translate: {
            x: action.coordinates.x - state.draggable.initialCoordinates.x,
            y: action.coordinates.y - state.draggable.initialCoordinates.y
          }
        }
      };

    case Action.DragEnd:
    case Action.DragCancel:
      return { ...state,
        draggable: { ...state.draggable,
          active: null,
          initialCoordinates: {
            x: 0,
            y: 0
          },
          translate: {
            x: 0,
            y: 0
          }
        }
      };

    case Action.RegisterDroppable:
      {
        const {
          element
        } = action;
        const {
          id
        } = element;
        const containers = new DroppableContainersMap(state.droppable.containers);
        containers.set(id, element);
        return { ...state,
          droppable: { ...state.droppable,
            containers
          }
        };
      }

    case Action.SetDroppableDisabled:
      {
        const {
          id,
          key,
          disabled
        } = action;
        const element = state.droppable.containers.get(id);

        if (!element || key !== element.key) {
          return state;
        }

        const containers = new DroppableContainersMap(state.droppable.containers);
        containers.set(id, { ...element,
          disabled
        });
        return { ...state,
          droppable: { ...state.droppable,
            containers
          }
        };
      }

    case Action.UnregisterDroppable:
      {
        const {
          id,
          key
        } = action;
        const element = state.droppable.containers.get(id);

        if (!element || key !== element.key) {
          return state;
        }

        const containers = new DroppableContainersMap(state.droppable.containers);
        containers.delete(id);
        return { ...state,
          droppable: { ...state.droppable,
            containers
          }
        };
      }

    default:
      {
        return state;
      }
  }
}

function RestoreFocus(_ref) {
  let {
    disabled
  } = _ref;
  const {
    active,
    activatorEvent,
    draggableNodes
  } = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(InternalContext);
  const previousActivatorEvent = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.usePrevious)(activatorEvent);
  const previousActiveId = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.usePrevious)(active == null ? void 0 : active.id); // Restore keyboard focus on the activator node

  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (disabled) {
      return;
    }

    if (!activatorEvent && previousActivatorEvent && previousActiveId != null) {
      if (!(0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isKeyboardEvent)(previousActivatorEvent)) {
        return;
      }

      if (document.activeElement === previousActivatorEvent.target) {
        // No need to restore focus
        return;
      }

      const draggableNode = draggableNodes.get(previousActiveId);

      if (!draggableNode) {
        return;
      }

      const {
        activatorNode,
        node
      } = draggableNode;

      if (!activatorNode.current && !node.current) {
        return;
      }

      requestAnimationFrame(() => {
        for (const element of [activatorNode.current, node.current]) {
          if (!element) {
            continue;
          }

          const focusableNode = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.findFirstFocusableNode)(element);

          if (focusableNode) {
            focusableNode.focus();
            break;
          }
        }
      });
    }
  }, [activatorEvent, disabled, draggableNodes, previousActiveId, previousActivatorEvent]);
  return null;
}

function applyModifiers(modifiers, _ref) {
  let {
    transform,
    ...args
  } = _ref;
  return modifiers != null && modifiers.length ? modifiers.reduce((accumulator, modifier) => {
    return modifier({
      transform: accumulator,
      ...args
    });
  }, transform) : transform;
}

function useMeasuringConfiguration(config) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    draggable: { ...defaultMeasuringConfiguration.draggable,
      ...(config == null ? void 0 : config.draggable)
    },
    droppable: { ...defaultMeasuringConfiguration.droppable,
      ...(config == null ? void 0 : config.droppable)
    },
    dragOverlay: { ...defaultMeasuringConfiguration.dragOverlay,
      ...(config == null ? void 0 : config.dragOverlay)
    }
  }), // eslint-disable-next-line react-hooks/exhaustive-deps
  [config == null ? void 0 : config.draggable, config == null ? void 0 : config.droppable, config == null ? void 0 : config.dragOverlay]);
}

function useLayoutShiftScrollCompensation(_ref) {
  let {
    activeNode,
    measure,
    initialRect,
    config = true
  } = _ref;
  const initialized = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
  const {
    x,
    y
  } = typeof config === 'boolean' ? {
    x: config,
    y: config
  } : config;
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    const disabled = !x && !y;

    if (disabled || !activeNode) {
      initialized.current = false;
      return;
    }

    if (initialized.current || !initialRect) {
      // Return early if layout shift scroll compensation was already attempted
      // or if there is no initialRect to compare to.
      return;
    } // Get the most up to date node ref for the active draggable


    const node = activeNode == null ? void 0 : activeNode.node.current;

    if (!node || node.isConnected === false) {
      // Return early if there is no attached node ref or if the node is
      // disconnected from the document.
      return;
    }

    const rect = measure(node);
    const rectDelta = getRectDelta(rect, initialRect);

    if (!x) {
      rectDelta.x = 0;
    }

    if (!y) {
      rectDelta.y = 0;
    } // Only perform layout shift scroll compensation once


    initialized.current = true;

    if (Math.abs(rectDelta.x) > 0 || Math.abs(rectDelta.y) > 0) {
      const firstScrollableAncestor = getFirstScrollableAncestor(node);

      if (firstScrollableAncestor) {
        firstScrollableAncestor.scrollBy({
          top: rectDelta.y,
          left: rectDelta.x
        });
      }
    }
  }, [activeNode, x, y, initialRect, measure]);
}

const ActiveDraggableContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)({ ...defaultCoordinates,
  scaleX: 1,
  scaleY: 1
});
var Status;

(function (Status) {
  Status[Status["Uninitialized"] = 0] = "Uninitialized";
  Status[Status["Initializing"] = 1] = "Initializing";
  Status[Status["Initialized"] = 2] = "Initialized";
})(Status || (Status = {}));

const DndContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.memo)(function DndContext(_ref) {
  var _sensorContext$curren, _dragOverlay$nodeRef$, _dragOverlay$rect, _over$rect;

  let {
    id,
    accessibility,
    autoScroll = true,
    children,
    sensors = defaultSensors,
    collisionDetection = rectIntersection,
    measuring,
    modifiers,
    ...props
  } = _ref;
  const store = (0,react__WEBPACK_IMPORTED_MODULE_0__.useReducer)(reducer, undefined, getInitialState);
  const [state, dispatch] = store;
  const [dispatchMonitorEvent, registerMonitorListener] = useDndMonitorProvider();
  const [status, setStatus] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(Status.Uninitialized);
  const isInitialized = status === Status.Initialized;
  const {
    draggable: {
      active: activeId,
      nodes: draggableNodes,
      translate
    },
    droppable: {
      containers: droppableContainers
    }
  } = state;
  const node = activeId != null ? draggableNodes.get(activeId) : null;
  const activeRects = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    initial: null,
    translated: null
  });
  const active = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    var _node$data;

    return activeId != null ? {
      id: activeId,
      // It's possible for the active node to unmount while dragging
      data: (_node$data = node == null ? void 0 : node.data) != null ? _node$data : defaultData,
      rect: activeRects
    } : null;
  }, [activeId, node]);
  const activeRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const [activeSensor, setActiveSensor] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const [activatorEvent, setActivatorEvent] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const latestProps = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLatestValue)(props, Object.values(props));
  const draggableDescribedById = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useUniqueId)("DndDescribedBy", id);
  const enabledDroppableContainers = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => droppableContainers.getEnabled(), [droppableContainers]);
  const measuringConfiguration = useMeasuringConfiguration(measuring);
  const {
    droppableRects,
    measureDroppableContainers,
    measuringScheduled
  } = useDroppableMeasuring(enabledDroppableContainers, {
    dragging: isInitialized,
    dependencies: [translate.x, translate.y],
    config: measuringConfiguration.droppable
  });
  const activeNode = useCachedNode(draggableNodes, activeId);
  const activationCoordinates = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => activatorEvent ? (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getEventCoordinates)(activatorEvent) : null, [activatorEvent]);
  const autoScrollOptions = getAutoScrollerOptions();
  const initialActiveNodeRect = useInitialRect(activeNode, measuringConfiguration.draggable.measure);
  useLayoutShiftScrollCompensation({
    activeNode: activeId != null ? draggableNodes.get(activeId) : null,
    config: autoScrollOptions.layoutShiftCompensation,
    initialRect: initialActiveNodeRect,
    measure: measuringConfiguration.draggable.measure
  });
  const activeNodeRect = useRect(activeNode, measuringConfiguration.draggable.measure, initialActiveNodeRect);
  const containerNodeRect = useRect(activeNode ? activeNode.parentElement : null);
  const sensorContext = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    activatorEvent: null,
    active: null,
    activeNode,
    collisionRect: null,
    collisions: null,
    droppableRects,
    draggableNodes,
    draggingNode: null,
    draggingNodeRect: null,
    droppableContainers,
    over: null,
    scrollableAncestors: [],
    scrollAdjustedTranslate: null
  });
  const overNode = droppableContainers.getNodeFor((_sensorContext$curren = sensorContext.current.over) == null ? void 0 : _sensorContext$curren.id);
  const dragOverlay = useDragOverlayMeasuring({
    measure: measuringConfiguration.dragOverlay.measure
  }); // Use the rect of the drag overlay if it is mounted

  const draggingNode = (_dragOverlay$nodeRef$ = dragOverlay.nodeRef.current) != null ? _dragOverlay$nodeRef$ : activeNode;
  const draggingNodeRect = isInitialized ? (_dragOverlay$rect = dragOverlay.rect) != null ? _dragOverlay$rect : activeNodeRect : null;
  const usesDragOverlay = Boolean(dragOverlay.nodeRef.current && dragOverlay.rect); // The delta between the previous and new position of the draggable node
  // is only relevant when there is no drag overlay

  const nodeRectDelta = useRectDelta(usesDragOverlay ? null : activeNodeRect); // Get the window rect of the dragging node

  const windowRect = useWindowRect(draggingNode ? (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(draggingNode) : null); // Get scrollable ancestors of the dragging node

  const scrollableAncestors = useScrollableAncestors(isInitialized ? overNode != null ? overNode : activeNode : null);
  const scrollableAncestorRects = useRects(scrollableAncestors); // Apply modifiers

  const modifiedTranslate = applyModifiers(modifiers, {
    transform: {
      x: translate.x - nodeRectDelta.x,
      y: translate.y - nodeRectDelta.y,
      scaleX: 1,
      scaleY: 1
    },
    activatorEvent,
    active,
    activeNodeRect,
    containerNodeRect,
    draggingNodeRect,
    over: sensorContext.current.over,
    overlayNodeRect: dragOverlay.rect,
    scrollableAncestors,
    scrollableAncestorRects,
    windowRect
  });
  const pointerCoordinates = activationCoordinates ? (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)(activationCoordinates, translate) : null;
  const scrollOffsets = useScrollOffsets(scrollableAncestors); // Represents the scroll delta since dragging was initiated

  const scrollAdjustment = useScrollOffsetsDelta(scrollOffsets); // Represents the scroll delta since the last time the active node rect was measured

  const activeNodeScrollDelta = useScrollOffsetsDelta(scrollOffsets, [activeNodeRect]);
  const scrollAdjustedTranslate = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)(modifiedTranslate, scrollAdjustment);
  const collisionRect = draggingNodeRect ? getAdjustedRect(draggingNodeRect, modifiedTranslate) : null;
  const collisions = active && collisionRect ? collisionDetection({
    active,
    collisionRect,
    droppableRects,
    droppableContainers: enabledDroppableContainers,
    pointerCoordinates
  }) : null;
  const overId = getFirstCollision(collisions, 'id');
  const [over, setOver] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null); // When there is no drag overlay used, we need to account for the
  // window scroll delta

  const appliedTranslate = usesDragOverlay ? modifiedTranslate : (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.add)(modifiedTranslate, activeNodeScrollDelta);
  const transform = adjustScale(appliedTranslate, (_over$rect = over == null ? void 0 : over.rect) != null ? _over$rect : null, activeNodeRect);
  const activeSensorRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const instantiateSensor = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((event, _ref2) => {
    let {
      sensor: Sensor,
      options
    } = _ref2;

    if (activeRef.current == null) {
      return;
    }

    const activeNode = draggableNodes.get(activeRef.current);

    if (!activeNode) {
      return;
    }

    const activatorEvent = event.nativeEvent;
    const sensorInstance = new Sensor({
      active: activeRef.current,
      activeNode,
      event: activatorEvent,
      options,
      // Sensors need to be instantiated with refs for arguments that change over time
      // otherwise they are frozen in time with the stale arguments
      context: sensorContext,

      onAbort(id) {
        const draggableNode = draggableNodes.get(id);

        if (!draggableNode) {
          return;
        }

        const {
          onDragAbort
        } = latestProps.current;
        const event = {
          id
        };
        onDragAbort == null ? void 0 : onDragAbort(event);
        dispatchMonitorEvent({
          type: 'onDragAbort',
          event
        });
      },

      onPending(id, constraint, initialCoordinates, offset) {
        const draggableNode = draggableNodes.get(id);

        if (!draggableNode) {
          return;
        }

        const {
          onDragPending
        } = latestProps.current;
        const event = {
          id,
          constraint,
          initialCoordinates,
          offset
        };
        onDragPending == null ? void 0 : onDragPending(event);
        dispatchMonitorEvent({
          type: 'onDragPending',
          event
        });
      },

      onStart(initialCoordinates) {
        const id = activeRef.current;

        if (id == null) {
          return;
        }

        const draggableNode = draggableNodes.get(id);

        if (!draggableNode) {
          return;
        }

        const {
          onDragStart
        } = latestProps.current;
        const event = {
          activatorEvent,
          active: {
            id,
            data: draggableNode.data,
            rect: activeRects
          }
        };
        (0,react_dom__WEBPACK_IMPORTED_MODULE_1__.unstable_batchedUpdates)(() => {
          onDragStart == null ? void 0 : onDragStart(event);
          setStatus(Status.Initializing);
          dispatch({
            type: Action.DragStart,
            initialCoordinates,
            active: id
          });
          dispatchMonitorEvent({
            type: 'onDragStart',
            event
          });
          setActiveSensor(activeSensorRef.current);
          setActivatorEvent(activatorEvent);
        });
      },

      onMove(coordinates) {
        dispatch({
          type: Action.DragMove,
          coordinates
        });
      },

      onEnd: createHandler(Action.DragEnd),
      onCancel: createHandler(Action.DragCancel)
    });
    activeSensorRef.current = sensorInstance;

    function createHandler(type) {
      return async function handler() {
        const {
          active,
          collisions,
          over,
          scrollAdjustedTranslate
        } = sensorContext.current;
        let event = null;

        if (active && scrollAdjustedTranslate) {
          const {
            cancelDrop
          } = latestProps.current;
          event = {
            activatorEvent,
            active: active,
            collisions,
            delta: scrollAdjustedTranslate,
            over
          };

          if (type === Action.DragEnd && typeof cancelDrop === 'function') {
            const shouldCancel = await Promise.resolve(cancelDrop(event));

            if (shouldCancel) {
              type = Action.DragCancel;
            }
          }
        }

        activeRef.current = null;
        (0,react_dom__WEBPACK_IMPORTED_MODULE_1__.unstable_batchedUpdates)(() => {
          dispatch({
            type
          });
          setStatus(Status.Uninitialized);
          setOver(null);
          setActiveSensor(null);
          setActivatorEvent(null);
          activeSensorRef.current = null;
          const eventName = type === Action.DragEnd ? 'onDragEnd' : 'onDragCancel';

          if (event) {
            const handler = latestProps.current[eventName];
            handler == null ? void 0 : handler(event);
            dispatchMonitorEvent({
              type: eventName,
              event
            });
          }
        });
      };
    }
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [draggableNodes]);
  const bindActivatorToSensorInstantiator = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((handler, sensor) => {
    return (event, active) => {
      const nativeEvent = event.nativeEvent;
      const activeDraggableNode = draggableNodes.get(active);

      if ( // Another sensor is already instantiating
      activeRef.current !== null || // No active draggable
      !activeDraggableNode || // Event has already been captured
      nativeEvent.dndKit || nativeEvent.defaultPrevented) {
        return;
      }

      const activationContext = {
        active: activeDraggableNode
      };
      const shouldActivate = handler(event, sensor.options, activationContext);

      if (shouldActivate === true) {
        nativeEvent.dndKit = {
          capturedBy: sensor.sensor
        };
        activeRef.current = active;
        instantiateSensor(event, sensor);
      }
    };
  }, [draggableNodes, instantiateSensor]);
  const activators = useCombineActivators(sensors, bindActivatorToSensorInstantiator);
  useSensorSetup(sensors);
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    if (activeNodeRect && status === Status.Initializing) {
      setStatus(Status.Initialized);
    }
  }, [activeNodeRect, status]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    const {
      onDragMove
    } = latestProps.current;
    const {
      active,
      activatorEvent,
      collisions,
      over
    } = sensorContext.current;

    if (!active || !activatorEvent) {
      return;
    }

    const event = {
      active,
      activatorEvent,
      collisions,
      delta: {
        x: scrollAdjustedTranslate.x,
        y: scrollAdjustedTranslate.y
      },
      over
    };
    (0,react_dom__WEBPACK_IMPORTED_MODULE_1__.unstable_batchedUpdates)(() => {
      onDragMove == null ? void 0 : onDragMove(event);
      dispatchMonitorEvent({
        type: 'onDragMove',
        event
      });
    });
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [scrollAdjustedTranslate.x, scrollAdjustedTranslate.y]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    const {
      active,
      activatorEvent,
      collisions,
      droppableContainers,
      scrollAdjustedTranslate
    } = sensorContext.current;

    if (!active || activeRef.current == null || !activatorEvent || !scrollAdjustedTranslate) {
      return;
    }

    const {
      onDragOver
    } = latestProps.current;
    const overContainer = droppableContainers.get(overId);
    const over = overContainer && overContainer.rect.current ? {
      id: overContainer.id,
      rect: overContainer.rect.current,
      data: overContainer.data,
      disabled: overContainer.disabled
    } : null;
    const event = {
      active,
      activatorEvent,
      collisions,
      delta: {
        x: scrollAdjustedTranslate.x,
        y: scrollAdjustedTranslate.y
      },
      over
    };
    (0,react_dom__WEBPACK_IMPORTED_MODULE_1__.unstable_batchedUpdates)(() => {
      setOver(over);
      onDragOver == null ? void 0 : onDragOver(event);
      dispatchMonitorEvent({
        type: 'onDragOver',
        event
      });
    });
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [overId]);
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    sensorContext.current = {
      activatorEvent,
      active,
      activeNode,
      collisionRect,
      collisions,
      droppableRects,
      draggableNodes,
      draggingNode,
      draggingNodeRect,
      droppableContainers,
      over,
      scrollableAncestors,
      scrollAdjustedTranslate
    };
    activeRects.current = {
      initial: draggingNodeRect,
      translated: collisionRect
    };
  }, [active, activeNode, collisions, collisionRect, draggableNodes, draggingNode, draggingNodeRect, droppableRects, droppableContainers, over, scrollableAncestors, scrollAdjustedTranslate]);
  useAutoScroller({ ...autoScrollOptions,
    delta: translate,
    draggingRect: collisionRect,
    pointerCoordinates,
    scrollableAncestors,
    scrollableAncestorRects
  });
  const publicContext = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    const context = {
      active,
      activeNode,
      activeNodeRect,
      activatorEvent,
      collisions,
      containerNodeRect,
      dragOverlay,
      draggableNodes,
      droppableContainers,
      droppableRects,
      over,
      measureDroppableContainers,
      scrollableAncestors,
      scrollableAncestorRects,
      measuringConfiguration,
      measuringScheduled,
      windowRect
    };
    return context;
  }, [active, activeNode, activeNodeRect, activatorEvent, collisions, containerNodeRect, dragOverlay, draggableNodes, droppableContainers, droppableRects, over, measureDroppableContainers, scrollableAncestors, scrollableAncestorRects, measuringConfiguration, measuringScheduled, windowRect]);
  const internalContext = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    const context = {
      activatorEvent,
      activators,
      active,
      activeNodeRect,
      ariaDescribedById: {
        draggable: draggableDescribedById
      },
      dispatch,
      draggableNodes,
      over,
      measureDroppableContainers
    };
    return context;
  }, [activatorEvent, activators, active, activeNodeRect, dispatch, draggableDescribedById, draggableNodes, over, measureDroppableContainers]);
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement(DndMonitorContext.Provider, {
    value: registerMonitorListener
  }, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(InternalContext.Provider, {
    value: internalContext
  }, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(PublicContext.Provider, {
    value: publicContext
  }, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(ActiveDraggableContext.Provider, {
    value: transform
  }, children)), react__WEBPACK_IMPORTED_MODULE_0___default().createElement(RestoreFocus, {
    disabled: (accessibility == null ? void 0 : accessibility.restoreFocus) === false
  })), react__WEBPACK_IMPORTED_MODULE_0___default().createElement(Accessibility, { ...accessibility,
    hiddenTextDescribedById: draggableDescribedById
  }));

  function getAutoScrollerOptions() {
    const activeSensorDisablesAutoscroll = (activeSensor == null ? void 0 : activeSensor.autoScrollEnabled) === false;
    const autoScrollGloballyDisabled = typeof autoScroll === 'object' ? autoScroll.enabled === false : autoScroll === false;
    const enabled = isInitialized && !activeSensorDisablesAutoscroll && !autoScrollGloballyDisabled;

    if (typeof autoScroll === 'object') {
      return { ...autoScroll,
        enabled
      };
    }

    return {
      enabled
    };
  }
});

const NullContext = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.createContext)(null);
const defaultRole = 'button';
const ID_PREFIX = 'Draggable';
function useDraggable(_ref) {
  let {
    id,
    data,
    disabled = false,
    attributes
  } = _ref;
  const key = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useUniqueId)(ID_PREFIX);
  const {
    activators,
    activatorEvent,
    active,
    activeNodeRect,
    ariaDescribedById,
    draggableNodes,
    over
  } = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(InternalContext);
  const {
    role = defaultRole,
    roleDescription = 'draggable',
    tabIndex = 0
  } = attributes != null ? attributes : {};
  const isDragging = (active == null ? void 0 : active.id) === id;
  const transform = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(isDragging ? ActiveDraggableContext : NullContext);
  const [node, setNodeRef] = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useNodeRef)();
  const [activatorNode, setActivatorNodeRef] = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useNodeRef)();
  const listeners = useSyntheticListeners(activators, id);
  const dataRef = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLatestValue)(data);
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    draggableNodes.set(id, {
      id,
      key,
      node,
      activatorNode,
      data: dataRef
    });
    return () => {
      const node = draggableNodes.get(id);

      if (node && node.key === key) {
        draggableNodes.delete(id);
      }
    };
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [draggableNodes, id]);
  const memoizedAttributes = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    role,
    tabIndex,
    'aria-disabled': disabled,
    'aria-pressed': isDragging && role === defaultRole ? true : undefined,
    'aria-roledescription': roleDescription,
    'aria-describedby': ariaDescribedById.draggable
  }), [disabled, role, tabIndex, isDragging, roleDescription, ariaDescribedById.draggable]);
  return {
    active,
    activatorEvent,
    activeNodeRect,
    attributes: memoizedAttributes,
    isDragging,
    listeners: disabled ? undefined : listeners,
    node,
    over,
    setNodeRef,
    setActivatorNodeRef,
    transform
  };
}

function useDndContext() {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(PublicContext);
}

const ID_PREFIX$1 = 'Droppable';
const defaultResizeObserverConfig = {
  timeout: 25
};
function useDroppable(_ref) {
  let {
    data,
    disabled = false,
    id,
    resizeObserverConfig
  } = _ref;
  const key = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useUniqueId)(ID_PREFIX$1);
  const {
    active,
    dispatch,
    over,
    measureDroppableContainers
  } = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(InternalContext);
  const previous = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    disabled
  });
  const resizeObserverConnected = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(false);
  const rect = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const callbackId = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const {
    disabled: resizeObserverDisabled,
    updateMeasurementsFor,
    timeout: resizeObserverTimeout
  } = { ...defaultResizeObserverConfig,
    ...resizeObserverConfig
  };
  const ids = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLatestValue)(updateMeasurementsFor != null ? updateMeasurementsFor : id);
  const handleResize = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(() => {
    if (!resizeObserverConnected.current) {
      // ResizeObserver invokes the `handleResize` callback as soon as `observe` is called,
      // assuming the element is rendered and displayed.
      resizeObserverConnected.current = true;
      return;
    }

    if (callbackId.current != null) {
      clearTimeout(callbackId.current);
    }

    callbackId.current = setTimeout(() => {
      measureDroppableContainers(Array.isArray(ids.current) ? ids.current : [ids.current]);
      callbackId.current = null;
    }, resizeObserverTimeout);
  }, //eslint-disable-next-line react-hooks/exhaustive-deps
  [resizeObserverTimeout]);
  const resizeObserver = useResizeObserver({
    callback: handleResize,
    disabled: resizeObserverDisabled || !active
  });
  const handleNodeChange = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((newElement, previousElement) => {
    if (!resizeObserver) {
      return;
    }

    if (previousElement) {
      resizeObserver.unobserve(previousElement);
      resizeObserverConnected.current = false;
    }

    if (newElement) {
      resizeObserver.observe(newElement);
    }
  }, [resizeObserver]);
  const [nodeRef, setNodeRef] = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useNodeRef)(handleNodeChange);
  const dataRef = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useLatestValue)(data);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (!resizeObserver || !nodeRef.current) {
      return;
    }

    resizeObserver.disconnect();
    resizeObserverConnected.current = false;
    resizeObserver.observe(nodeRef.current);
  }, [nodeRef, resizeObserver]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    dispatch({
      type: Action.RegisterDroppable,
      element: {
        id,
        key,
        disabled,
        node: nodeRef,
        rect,
        data: dataRef
      }
    });
    return () => dispatch({
      type: Action.UnregisterDroppable,
      key,
      id
    });
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [id]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (disabled !== previous.current.disabled) {
      dispatch({
        type: Action.SetDroppableDisabled,
        id,
        key,
        disabled
      });
      previous.current.disabled = disabled;
    }
  }, [id, key, disabled, dispatch]);
  return {
    active,
    rect,
    isOver: (over == null ? void 0 : over.id) === id,
    node: nodeRef,
    over,
    setNodeRef
  };
}

function AnimationManager(_ref) {
  let {
    animation,
    children
  } = _ref;
  const [clonedChildren, setClonedChildren] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const [element, setElement] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const previousChildren = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.usePrevious)(children);

  if (!children && !clonedChildren && previousChildren) {
    setClonedChildren(previousChildren);
  }

  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    if (!element) {
      return;
    }

    const key = clonedChildren == null ? void 0 : clonedChildren.key;
    const id = clonedChildren == null ? void 0 : clonedChildren.props.id;

    if (key == null || id == null) {
      setClonedChildren(null);
      return;
    }

    Promise.resolve(animation(id, element)).then(() => {
      setClonedChildren(null);
    });
  }, [animation, clonedChildren, element]);
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement((react__WEBPACK_IMPORTED_MODULE_0___default().Fragment), null, children, clonedChildren ? (0,react__WEBPACK_IMPORTED_MODULE_0__.cloneElement)(clonedChildren, {
    ref: setElement
  }) : null);
}

const defaultTransform = {
  x: 0,
  y: 0,
  scaleX: 1,
  scaleY: 1
};
function NullifiedContextProvider(_ref) {
  let {
    children
  } = _ref;
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement(InternalContext.Provider, {
    value: defaultInternalContext
  }, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(ActiveDraggableContext.Provider, {
    value: defaultTransform
  }, children));
}

const baseStyles = {
  position: 'fixed',
  touchAction: 'none'
};

const defaultTransition = activatorEvent => {
  const isKeyboardActivator = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isKeyboardEvent)(activatorEvent);
  return isKeyboardActivator ? 'transform 250ms ease' : undefined;
};

const PositionedOverlay = /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)((_ref, ref) => {
  let {
    as,
    activatorEvent,
    adjustScale,
    children,
    className,
    rect,
    style,
    transform,
    transition = defaultTransition
  } = _ref;

  if (!rect) {
    return null;
  }

  const scaleAdjustedTransform = adjustScale ? transform : { ...transform,
    scaleX: 1,
    scaleY: 1
  };
  const styles = { ...baseStyles,
    width: rect.width,
    height: rect.height,
    top: rect.top,
    left: rect.left,
    transform: _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transform.toString(scaleAdjustedTransform),
    transformOrigin: adjustScale && activatorEvent ? getRelativeTransformOrigin(activatorEvent, rect) : undefined,
    transition: typeof transition === 'function' ? transition(activatorEvent) : transition,
    ...style
  };
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement(as, {
    className,
    style: styles,
    ref
  }, children);
});

const defaultDropAnimationSideEffects = options => _ref => {
  let {
    active,
    dragOverlay
  } = _ref;
  const originalStyles = {};
  const {
    styles,
    className
  } = options;

  if (styles != null && styles.active) {
    for (const [key, value] of Object.entries(styles.active)) {
      if (value === undefined) {
        continue;
      }

      originalStyles[key] = active.node.style.getPropertyValue(key);
      active.node.style.setProperty(key, value);
    }
  }

  if (styles != null && styles.dragOverlay) {
    for (const [key, value] of Object.entries(styles.dragOverlay)) {
      if (value === undefined) {
        continue;
      }

      dragOverlay.node.style.setProperty(key, value);
    }
  }

  if (className != null && className.active) {
    active.node.classList.add(className.active);
  }

  if (className != null && className.dragOverlay) {
    dragOverlay.node.classList.add(className.dragOverlay);
  }

  return function cleanup() {
    for (const [key, value] of Object.entries(originalStyles)) {
      active.node.style.setProperty(key, value);
    }

    if (className != null && className.active) {
      active.node.classList.remove(className.active);
    }
  };
};

const defaultKeyframeResolver = _ref2 => {
  let {
    transform: {
      initial,
      final
    }
  } = _ref2;
  return [{
    transform: _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transform.toString(initial)
  }, {
    transform: _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transform.toString(final)
  }];
};

const defaultDropAnimationConfiguration = {
  duration: 250,
  easing: 'ease',
  keyframes: defaultKeyframeResolver,
  sideEffects: /*#__PURE__*/defaultDropAnimationSideEffects({
    styles: {
      active: {
        opacity: '0'
      }
    }
  })
};
function useDropAnimation(_ref3) {
  let {
    config,
    draggableNodes,
    droppableContainers,
    measuringConfiguration
  } = _ref3;
  return (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useEvent)((id, node) => {
    if (config === null) {
      return;
    }

    const activeDraggable = draggableNodes.get(id);

    if (!activeDraggable) {
      return;
    }

    const activeNode = activeDraggable.node.current;

    if (!activeNode) {
      return;
    }

    const measurableNode = getMeasurableNode(node);

    if (!measurableNode) {
      return;
    }

    const {
      transform
    } = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.getWindow)(node).getComputedStyle(node);
    const parsedTransform = parseTransform(transform);

    if (!parsedTransform) {
      return;
    }

    const animation = typeof config === 'function' ? config : createDefaultDropAnimation(config);
    scrollIntoViewIfNeeded(activeNode, measuringConfiguration.draggable.measure);
    return animation({
      active: {
        id,
        data: activeDraggable.data,
        node: activeNode,
        rect: measuringConfiguration.draggable.measure(activeNode)
      },
      draggableNodes,
      dragOverlay: {
        node,
        rect: measuringConfiguration.dragOverlay.measure(measurableNode)
      },
      droppableContainers,
      measuringConfiguration,
      transform: parsedTransform
    });
  });
}

function createDefaultDropAnimation(options) {
  const {
    duration,
    easing,
    sideEffects,
    keyframes
  } = { ...defaultDropAnimationConfiguration,
    ...options
  };
  return _ref4 => {
    let {
      active,
      dragOverlay,
      transform,
      ...rest
    } = _ref4;

    if (!duration) {
      // Do not animate if animation duration is zero.
      return;
    }

    const delta = {
      x: dragOverlay.rect.left - active.rect.left,
      y: dragOverlay.rect.top - active.rect.top
    };
    const scale = {
      scaleX: transform.scaleX !== 1 ? active.rect.width * transform.scaleX / dragOverlay.rect.width : 1,
      scaleY: transform.scaleY !== 1 ? active.rect.height * transform.scaleY / dragOverlay.rect.height : 1
    };
    const finalTransform = {
      x: transform.x - delta.x,
      y: transform.y - delta.y,
      ...scale
    };
    const animationKeyframes = keyframes({ ...rest,
      active,
      dragOverlay,
      transform: {
        initial: transform,
        final: finalTransform
      }
    });
    const [firstKeyframe] = animationKeyframes;
    const lastKeyframe = animationKeyframes[animationKeyframes.length - 1];

    if (JSON.stringify(firstKeyframe) === JSON.stringify(lastKeyframe)) {
      // The start and end keyframes are the same, infer that there is no animation needed.
      return;
    }

    const cleanup = sideEffects == null ? void 0 : sideEffects({
      active,
      dragOverlay,
      ...rest
    });
    const animation = dragOverlay.node.animate(animationKeyframes, {
      duration,
      easing,
      fill: 'forwards'
    });
    return new Promise(resolve => {
      animation.onfinish = () => {
        cleanup == null ? void 0 : cleanup();
        resolve();
      };
    });
  };
}

let key = 0;
function useKey(id) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    if (id == null) {
      return;
    }

    key++;
    return key;
  }, [id]);
}

const DragOverlay = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0___default().memo(_ref => {
  let {
    adjustScale = false,
    children,
    dropAnimation: dropAnimationConfig,
    style,
    transition,
    modifiers,
    wrapperElement = 'div',
    className,
    zIndex = 999
  } = _ref;
  const {
    activatorEvent,
    active,
    activeNodeRect,
    containerNodeRect,
    draggableNodes,
    droppableContainers,
    dragOverlay,
    over,
    measuringConfiguration,
    scrollableAncestors,
    scrollableAncestorRects,
    windowRect
  } = useDndContext();
  const transform = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(ActiveDraggableContext);
  const key = useKey(active == null ? void 0 : active.id);
  const modifiedTransform = applyModifiers(modifiers, {
    activatorEvent,
    active,
    activeNodeRect,
    containerNodeRect,
    draggingNodeRect: dragOverlay.rect,
    over,
    overlayNodeRect: dragOverlay.rect,
    scrollableAncestors,
    scrollableAncestorRects,
    transform,
    windowRect
  });
  const initialRect = useInitialValue(activeNodeRect);
  const dropAnimation = useDropAnimation({
    config: dropAnimationConfig,
    draggableNodes,
    droppableContainers,
    measuringConfiguration
  }); // We need to wait for the active node to be measured before connecting the drag overlay ref
  // otherwise collisions can be computed against a mispositioned drag overlay

  const ref = initialRect ? dragOverlay.setRef : undefined;
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement(NullifiedContextProvider, null, react__WEBPACK_IMPORTED_MODULE_0___default().createElement(AnimationManager, {
    animation: dropAnimation
  }, active && key ? react__WEBPACK_IMPORTED_MODULE_0___default().createElement(PositionedOverlay, {
    key: key,
    id: active.id,
    ref: ref,
    as: wrapperElement,
    activatorEvent: activatorEvent,
    adjustScale: adjustScale,
    className: className,
    transition: transition,
    rect: initialRect,
    style: {
      zIndex,
      ...style
    },
    transform: modifiedTransform
  }, children) : null));
});


//# sourceMappingURL=core.esm.js.map


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/sortable/dist/sortable.esm.js":
/*!*******************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@dnd-kit/sortable/dist/sortable.esm.js ***!
  \*******************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   SortableContext: function() { return /* binding */ SortableContext; },
/* harmony export */   arrayMove: function() { return /* binding */ arrayMove; },
/* harmony export */   arraySwap: function() { return /* binding */ arraySwap; },
/* harmony export */   defaultAnimateLayoutChanges: function() { return /* binding */ defaultAnimateLayoutChanges; },
/* harmony export */   defaultNewIndexGetter: function() { return /* binding */ defaultNewIndexGetter; },
/* harmony export */   hasSortableData: function() { return /* binding */ hasSortableData; },
/* harmony export */   horizontalListSortingStrategy: function() { return /* binding */ horizontalListSortingStrategy; },
/* harmony export */   rectSortingStrategy: function() { return /* binding */ rectSortingStrategy; },
/* harmony export */   rectSwappingStrategy: function() { return /* binding */ rectSwappingStrategy; },
/* harmony export */   sortableKeyboardCoordinates: function() { return /* binding */ sortableKeyboardCoordinates; },
/* harmony export */   useSortable: function() { return /* binding */ useSortable; },
/* harmony export */   verticalListSortingStrategy: function() { return /* binding */ verticalListSortingStrategy; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @dnd-kit/core */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/core/dist/core.esm.js");
/* harmony import */ var _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @dnd-kit/utilities */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/utilities/dist/utilities.esm.js");




/**
 * Move an array item to a different position. Returns a new array with the item moved to the new position.
 */
function arrayMove(array, from, to) {
  const newArray = array.slice();
  newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);
  return newArray;
}

/**
 * Swap an array item to a different position. Returns a new array with the item swapped to the new position.
 */
function arraySwap(array, from, to) {
  const newArray = array.slice();
  newArray[from] = array[to];
  newArray[to] = array[from];
  return newArray;
}

function getSortedRects(items, rects) {
  return items.reduce((accumulator, id, index) => {
    const rect = rects.get(id);

    if (rect) {
      accumulator[index] = rect;
    }

    return accumulator;
  }, Array(items.length));
}

function isValidIndex(index) {
  return index !== null && index >= 0;
}

function itemsEqual(a, b) {
  if (a === b) {
    return true;
  }

  if (a.length !== b.length) {
    return false;
  }

  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) {
      return false;
    }
  }

  return true;
}

function normalizeDisabled(disabled) {
  if (typeof disabled === 'boolean') {
    return {
      draggable: disabled,
      droppable: disabled
    };
  }

  return disabled;
}

// To-do: We should be calculating scale transformation
const defaultScale = {
  scaleX: 1,
  scaleY: 1
};
const horizontalListSortingStrategy = _ref => {
  var _rects$activeIndex;

  let {
    rects,
    activeNodeRect: fallbackActiveRect,
    activeIndex,
    overIndex,
    index
  } = _ref;
  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;

  if (!activeNodeRect) {
    return null;
  }

  const itemGap = getItemGap(rects, index, activeIndex);

  if (index === activeIndex) {
    const newIndexRect = rects[overIndex];

    if (!newIndexRect) {
      return null;
    }

    return {
      x: activeIndex < overIndex ? newIndexRect.left + newIndexRect.width - (activeNodeRect.left + activeNodeRect.width) : newIndexRect.left - activeNodeRect.left,
      y: 0,
      ...defaultScale
    };
  }

  if (index > activeIndex && index <= overIndex) {
    return {
      x: -activeNodeRect.width - itemGap,
      y: 0,
      ...defaultScale
    };
  }

  if (index < activeIndex && index >= overIndex) {
    return {
      x: activeNodeRect.width + itemGap,
      y: 0,
      ...defaultScale
    };
  }

  return {
    x: 0,
    y: 0,
    ...defaultScale
  };
};

function getItemGap(rects, index, activeIndex) {
  const currentRect = rects[index];
  const previousRect = rects[index - 1];
  const nextRect = rects[index + 1];

  if (!currentRect || !previousRect && !nextRect) {
    return 0;
  }

  if (activeIndex < index) {
    return previousRect ? currentRect.left - (previousRect.left + previousRect.width) : nextRect.left - (currentRect.left + currentRect.width);
  }

  return nextRect ? nextRect.left - (currentRect.left + currentRect.width) : currentRect.left - (previousRect.left + previousRect.width);
}

const rectSortingStrategy = _ref => {
  let {
    rects,
    activeIndex,
    overIndex,
    index
  } = _ref;
  const newRects = arrayMove(rects, overIndex, activeIndex);
  const oldRect = rects[index];
  const newRect = newRects[index];

  if (!newRect || !oldRect) {
    return null;
  }

  return {
    x: newRect.left - oldRect.left,
    y: newRect.top - oldRect.top,
    scaleX: newRect.width / oldRect.width,
    scaleY: newRect.height / oldRect.height
  };
};

const rectSwappingStrategy = _ref => {
  let {
    activeIndex,
    index,
    rects,
    overIndex
  } = _ref;
  let oldRect;
  let newRect;

  if (index === activeIndex) {
    oldRect = rects[index];
    newRect = rects[overIndex];
  }

  if (index === overIndex) {
    oldRect = rects[index];
    newRect = rects[activeIndex];
  }

  if (!newRect || !oldRect) {
    return null;
  }

  return {
    x: newRect.left - oldRect.left,
    y: newRect.top - oldRect.top,
    scaleX: newRect.width / oldRect.width,
    scaleY: newRect.height / oldRect.height
  };
};

// To-do: We should be calculating scale transformation
const defaultScale$1 = {
  scaleX: 1,
  scaleY: 1
};
const verticalListSortingStrategy = _ref => {
  var _rects$activeIndex;

  let {
    activeIndex,
    activeNodeRect: fallbackActiveRect,
    index,
    rects,
    overIndex
  } = _ref;
  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;

  if (!activeNodeRect) {
    return null;
  }

  if (index === activeIndex) {
    const overIndexRect = rects[overIndex];

    if (!overIndexRect) {
      return null;
    }

    return {
      x: 0,
      y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top,
      ...defaultScale$1
    };
  }

  const itemGap = getItemGap$1(rects, index, activeIndex);

  if (index > activeIndex && index <= overIndex) {
    return {
      x: 0,
      y: -activeNodeRect.height - itemGap,
      ...defaultScale$1
    };
  }

  if (index < activeIndex && index >= overIndex) {
    return {
      x: 0,
      y: activeNodeRect.height + itemGap,
      ...defaultScale$1
    };
  }

  return {
    x: 0,
    y: 0,
    ...defaultScale$1
  };
};

function getItemGap$1(clientRects, index, activeIndex) {
  const currentRect = clientRects[index];
  const previousRect = clientRects[index - 1];
  const nextRect = clientRects[index + 1];

  if (!currentRect) {
    return 0;
  }

  if (activeIndex < index) {
    return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;
  }

  return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;
}

const ID_PREFIX = 'Sortable';
const Context = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0___default().createContext({
  activeIndex: -1,
  containerId: ID_PREFIX,
  disableTransforms: false,
  items: [],
  overIndex: -1,
  useDragOverlay: false,
  sortedRects: [],
  strategy: rectSortingStrategy,
  disabled: {
    draggable: false,
    droppable: false
  }
});
function SortableContext(_ref) {
  let {
    children,
    id,
    items: userDefinedItems,
    strategy = rectSortingStrategy,
    disabled: disabledProp = false
  } = _ref;
  const {
    active,
    dragOverlay,
    droppableRects,
    over,
    measureDroppableContainers
  } = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useDndContext)();
  const containerId = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useUniqueId)(ID_PREFIX, id);
  const useDragOverlay = Boolean(dragOverlay.rect !== null);
  const items = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => userDefinedItems.map(item => typeof item === 'object' && 'id' in item ? item.id : item), [userDefinedItems]);
  const isDragging = active != null;
  const activeIndex = active ? items.indexOf(active.id) : -1;
  const overIndex = over ? items.indexOf(over.id) : -1;
  const previousItemsRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(items);
  const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
  const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
  const disabled = normalizeDisabled(disabledProp);
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    if (itemsHaveChanged && isDragging) {
      measureDroppableContainers(items);
    }
  }, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    previousItemsRef.current = items;
  }, [items]);
  const contextValue = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    activeIndex,
    containerId,
    disabled,
    disableTransforms,
    items,
    overIndex,
    useDragOverlay,
    sortedRects: getSortedRects(items, droppableRects),
    strategy
  }), // eslint-disable-next-line react-hooks/exhaustive-deps
  [activeIndex, containerId, disabled.draggable, disabled.droppable, disableTransforms, items, overIndex, droppableRects, useDragOverlay, strategy]);
  return react__WEBPACK_IMPORTED_MODULE_0___default().createElement(Context.Provider, {
    value: contextValue
  }, children);
}

const defaultNewIndexGetter = _ref => {
  let {
    id,
    items,
    activeIndex,
    overIndex
  } = _ref;
  return arrayMove(items, activeIndex, overIndex).indexOf(id);
};
const defaultAnimateLayoutChanges = _ref2 => {
  let {
    containerId,
    isSorting,
    wasDragging,
    index,
    items,
    newIndex,
    previousItems,
    previousContainerId,
    transition
  } = _ref2;

  if (!transition || !wasDragging) {
    return false;
  }

  if (previousItems !== items && index === newIndex) {
    return false;
  }

  if (isSorting) {
    return true;
  }

  return newIndex !== index && containerId === previousContainerId;
};
const defaultTransition = {
  duration: 200,
  easing: 'ease'
};
const transitionProperty = 'transform';
const disabledTransition = /*#__PURE__*/_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transition.toString({
  property: transitionProperty,
  duration: 0,
  easing: 'linear'
});
const defaultAttributes = {
  roleDescription: 'sortable'
};

/*
 * When the index of an item changes while sorting,
 * we need to temporarily disable the transforms
 */

function useDerivedTransform(_ref) {
  let {
    disabled,
    index,
    node,
    rect
  } = _ref;
  const [derivedTransform, setDerivedtransform] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(null);
  const previousIndex = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(index);
  (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    if (!disabled && index !== previousIndex.current && node.current) {
      const initial = rect.current;

      if (initial) {
        const current = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.getClientRect)(node.current, {
          ignoreTransform: true
        });
        const delta = {
          x: initial.left - current.left,
          y: initial.top - current.top,
          scaleX: initial.width / current.width,
          scaleY: initial.height / current.height
        };

        if (delta.x || delta.y) {
          setDerivedtransform(delta);
        }
      }
    }

    if (index !== previousIndex.current) {
      previousIndex.current = index;
    }
  }, [disabled, index, node, rect]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (derivedTransform) {
      setDerivedtransform(null);
    }
  }, [derivedTransform]);
  return derivedTransform;
}

function useSortable(_ref) {
  let {
    animateLayoutChanges = defaultAnimateLayoutChanges,
    attributes: userDefinedAttributes,
    disabled: localDisabled,
    data: customData,
    getNewIndex = defaultNewIndexGetter,
    id,
    strategy: localStrategy,
    resizeObserverConfig,
    transition = defaultTransition
  } = _ref;
  const {
    items,
    containerId,
    activeIndex,
    disabled: globalDisabled,
    disableTransforms,
    sortedRects,
    overIndex,
    useDragOverlay,
    strategy: globalStrategy
  } = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(Context);
  const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
  const index = items.indexOf(id);
  const data = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => ({
    sortable: {
      containerId,
      index,
      items
    },
    ...customData
  }), [containerId, customData, index, items]);
  const itemsAfterCurrentSortable = (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => items.slice(items.indexOf(id)), [items, id]);
  const {
    rect,
    node,
    isOver,
    setNodeRef: setDroppableNodeRef
  } = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useDroppable)({
    id,
    data,
    disabled: disabled.droppable,
    resizeObserverConfig: {
      updateMeasurementsFor: itemsAfterCurrentSortable,
      ...resizeObserverConfig
    }
  });
  const {
    active,
    activatorEvent,
    activeNodeRect,
    attributes,
    setNodeRef: setDraggableNodeRef,
    listeners,
    isDragging,
    over,
    setActivatorNodeRef,
    transform
  } = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useDraggable)({
    id,
    data,
    attributes: { ...defaultAttributes,
      ...userDefinedAttributes
    },
    disabled: disabled.draggable
  });
  const setNodeRef = (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.useCombinedRefs)(setDroppableNodeRef, setDraggableNodeRef);
  const isSorting = Boolean(active);
  const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);
  const shouldDisplaceDragSource = !useDragOverlay && isDragging;
  const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;
  const strategy = localStrategy != null ? localStrategy : globalStrategy;
  const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : strategy({
    rects: sortedRects,
    activeNodeRect,
    activeIndex,
    overIndex,
    index
  }) : null;
  const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({
    id,
    items,
    activeIndex,
    overIndex
  }) : index;
  const activeId = active == null ? void 0 : active.id;
  const previous = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)({
    activeId,
    items,
    newIndex,
    containerId
  });
  const itemsHaveChanged = items !== previous.current.items;
  const shouldAnimateLayoutChanges = animateLayoutChanges({
    active,
    containerId,
    isDragging,
    isSorting,
    id,
    index,
    items,
    newIndex: previous.current.newIndex,
    previousItems: previous.current.items,
    previousContainerId: previous.current.containerId,
    transition,
    wasDragging: previous.current.activeId != null
  });
  const derivedTransform = useDerivedTransform({
    disabled: !shouldAnimateLayoutChanges,
    index,
    node,
    rect
  });
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (isSorting && previous.current.newIndex !== newIndex) {
      previous.current.newIndex = newIndex;
    }

    if (containerId !== previous.current.containerId) {
      previous.current.containerId = containerId;
    }

    if (items !== previous.current.items) {
      previous.current.items = items;
    }
  }, [isSorting, newIndex, containerId, items]);
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    if (activeId === previous.current.activeId) {
      return;
    }

    if (activeId != null && previous.current.activeId == null) {
      previous.current.activeId = activeId;
      return;
    }

    const timeoutId = setTimeout(() => {
      previous.current.activeId = activeId;
    }, 50);
    return () => clearTimeout(timeoutId);
  }, [activeId]);
  return {
    active,
    activeIndex,
    attributes,
    data,
    rect,
    index,
    newIndex,
    items,
    isOver,
    isSorting,
    isDragging,
    listeners,
    node,
    overIndex,
    over,
    setNodeRef,
    setActivatorNodeRef,
    setDroppableNodeRef,
    setDraggableNodeRef,
    transform: derivedTransform != null ? derivedTransform : finalTransform,
    transition: getTransition()
  };

  function getTransition() {
    if ( // Temporarily disable transitions for a single frame to set up derived transforms
    derivedTransform || // Or to prevent items jumping to back to their "new" position when items change
    itemsHaveChanged && previous.current.newIndex === index) {
      return disabledTransition;
    }

    if (shouldDisplaceDragSource && !(0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.isKeyboardEvent)(activatorEvent) || !transition) {
      return undefined;
    }

    if (isSorting || shouldAnimateLayoutChanges) {
      return _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transition.toString({ ...transition,
        property: transitionProperty
      });
    }

    return undefined;
  }
}

function normalizeLocalDisabled(localDisabled, globalDisabled) {
  var _localDisabled$dragga, _localDisabled$droppa;

  if (typeof localDisabled === 'boolean') {
    return {
      draggable: localDisabled,
      // Backwards compatibility
      droppable: false
    };
  }

  return {
    draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,
    droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable
  };
}

function hasSortableData(entry) {
  if (!entry) {
    return false;
  }

  const data = entry.data.current;

  if (data && 'sortable' in data && typeof data.sortable === 'object' && 'containerId' in data.sortable && 'items' in data.sortable && 'index' in data.sortable) {
    return true;
  }

  return false;
}

const directions = [_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Down, _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Right, _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Up, _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Left];
const sortableKeyboardCoordinates = (event, _ref) => {
  let {
    context: {
      active,
      collisionRect,
      droppableRects,
      droppableContainers,
      over,
      scrollableAncestors
    }
  } = _ref;

  if (directions.includes(event.code)) {
    event.preventDefault();

    if (!active || !collisionRect) {
      return;
    }

    const filteredContainers = [];
    droppableContainers.getEnabled().forEach(entry => {
      if (!entry || entry != null && entry.disabled) {
        return;
      }

      const rect = droppableRects.get(entry.id);

      if (!rect) {
        return;
      }

      switch (event.code) {
        case _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Down:
          if (collisionRect.top < rect.top) {
            filteredContainers.push(entry);
          }

          break;

        case _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Up:
          if (collisionRect.top > rect.top) {
            filteredContainers.push(entry);
          }

          break;

        case _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Left:
          if (collisionRect.left > rect.left) {
            filteredContainers.push(entry);
          }

          break;

        case _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardCode.Right:
          if (collisionRect.left < rect.left) {
            filteredContainers.push(entry);
          }

          break;
      }
    });
    const collisions = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.closestCorners)({
      active,
      collisionRect: collisionRect,
      droppableRects,
      droppableContainers: filteredContainers,
      pointerCoordinates: null
    });
    let closestId = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.getFirstCollision)(collisions, 'id');

    if (closestId === (over == null ? void 0 : over.id) && collisions.length > 1) {
      closestId = collisions[1].id;
    }

    if (closestId != null) {
      const activeDroppable = droppableContainers.get(active.id);
      const newDroppable = droppableContainers.get(closestId);
      const newRect = newDroppable ? droppableRects.get(newDroppable.id) : null;
      const newNode = newDroppable == null ? void 0 : newDroppable.node.current;

      if (newNode && newRect && activeDroppable && newDroppable) {
        const newScrollAncestors = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.getScrollableAncestors)(newNode);
        const hasDifferentScrollAncestors = newScrollAncestors.some((element, index) => scrollableAncestors[index] !== element);
        const hasSameContainer = isSameContainer(activeDroppable, newDroppable);
        const isAfterActive = isAfter(activeDroppable, newDroppable);
        const offset = hasDifferentScrollAncestors || !hasSameContainer ? {
          x: 0,
          y: 0
        } : {
          x: isAfterActive ? collisionRect.width - newRect.width : 0,
          y: isAfterActive ? collisionRect.height - newRect.height : 0
        };
        const rectCoordinates = {
          x: newRect.left,
          y: newRect.top
        };
        const newCoordinates = offset.x && offset.y ? rectCoordinates : (0,_dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.subtract)(rectCoordinates, offset);
        return newCoordinates;
      }
    }
  }

  return undefined;
};

function isSameContainer(a, b) {
  if (!hasSortableData(a) || !hasSortableData(b)) {
    return false;
  }

  return a.data.current.sortable.containerId === b.data.current.sortable.containerId;
}

function isAfter(a, b) {
  if (!hasSortableData(a) || !hasSortableData(b)) {
    return false;
  }

  if (!isSameContainer(a, b)) {
    return false;
  }

  return a.data.current.sortable.index < b.data.current.sortable.index;
}


//# sourceMappingURL=sortable.esm.js.map


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/utilities/dist/utilities.esm.js":
/*!*********************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@dnd-kit/utilities/dist/utilities.esm.js ***!
  \*********************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CSS: function() { return /* binding */ CSS; },
/* harmony export */   add: function() { return /* binding */ add; },
/* harmony export */   canUseDOM: function() { return /* binding */ canUseDOM; },
/* harmony export */   findFirstFocusableNode: function() { return /* binding */ findFirstFocusableNode; },
/* harmony export */   getEventCoordinates: function() { return /* binding */ getEventCoordinates; },
/* harmony export */   getOwnerDocument: function() { return /* binding */ getOwnerDocument; },
/* harmony export */   getWindow: function() { return /* binding */ getWindow; },
/* harmony export */   hasViewportRelativeCoordinates: function() { return /* binding */ hasViewportRelativeCoordinates; },
/* harmony export */   isDocument: function() { return /* binding */ isDocument; },
/* harmony export */   isHTMLElement: function() { return /* binding */ isHTMLElement; },
/* harmony export */   isKeyboardEvent: function() { return /* binding */ isKeyboardEvent; },
/* harmony export */   isNode: function() { return /* binding */ isNode; },
/* harmony export */   isSVGElement: function() { return /* binding */ isSVGElement; },
/* harmony export */   isTouchEvent: function() { return /* binding */ isTouchEvent; },
/* harmony export */   isWindow: function() { return /* binding */ isWindow; },
/* harmony export */   subtract: function() { return /* binding */ subtract; },
/* harmony export */   useCombinedRefs: function() { return /* binding */ useCombinedRefs; },
/* harmony export */   useEvent: function() { return /* binding */ useEvent; },
/* harmony export */   useInterval: function() { return /* binding */ useInterval; },
/* harmony export */   useIsomorphicLayoutEffect: function() { return /* binding */ useIsomorphicLayoutEffect; },
/* harmony export */   useLatestValue: function() { return /* binding */ useLatestValue; },
/* harmony export */   useLazyMemo: function() { return /* binding */ useLazyMemo; },
/* harmony export */   useNodeRef: function() { return /* binding */ useNodeRef; },
/* harmony export */   usePrevious: function() { return /* binding */ usePrevious; },
/* harmony export */   useUniqueId: function() { return /* binding */ useUniqueId; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);


function useCombinedRefs() {
  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
    refs[_key] = arguments[_key];
  }

  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => node => {
    refs.forEach(ref => ref(node));
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  refs);
}

// https://github.com/facebook/react/blob/master/packages/shared/ExecutionEnvironment.js
const canUseDOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';

function isWindow(element) {
  const elementString = Object.prototype.toString.call(element);
  return elementString === '[object Window]' || // In Electron context the Window object serializes to [object global]
  elementString === '[object global]';
}

function isNode(node) {
  return 'nodeType' in node;
}

function getWindow(target) {
  var _target$ownerDocument, _target$ownerDocument2;

  if (!target) {
    return window;
  }

  if (isWindow(target)) {
    return target;
  }

  if (!isNode(target)) {
    return window;
  }

  return (_target$ownerDocument = (_target$ownerDocument2 = target.ownerDocument) == null ? void 0 : _target$ownerDocument2.defaultView) != null ? _target$ownerDocument : window;
}

function isDocument(node) {
  const {
    Document
  } = getWindow(node);
  return node instanceof Document;
}

function isHTMLElement(node) {
  if (isWindow(node)) {
    return false;
  }

  return node instanceof getWindow(node).HTMLElement;
}

function isSVGElement(node) {
  return node instanceof getWindow(node).SVGElement;
}

function getOwnerDocument(target) {
  if (!target) {
    return document;
  }

  if (isWindow(target)) {
    return target.document;
  }

  if (!isNode(target)) {
    return document;
  }

  if (isDocument(target)) {
    return target;
  }

  if (isHTMLElement(target) || isSVGElement(target)) {
    return target.ownerDocument;
  }

  return document;
}

/**
 * A hook that resolves to useEffect on the server and useLayoutEffect on the client
 * @param callback {function} Callback function that is invoked when the dependencies of the hook change
 */

const useIsomorphicLayoutEffect = canUseDOM ? react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect : react__WEBPACK_IMPORTED_MODULE_0__.useEffect;

function useEvent(handler) {
  const handlerRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(handler);
  useIsomorphicLayoutEffect(() => {
    handlerRef.current = handler;
  });
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(function () {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return handlerRef.current == null ? void 0 : handlerRef.current(...args);
  }, []);
}

function useInterval() {
  const intervalRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const set = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)((listener, duration) => {
    intervalRef.current = setInterval(listener, duration);
  }, []);
  const clear = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(() => {
    if (intervalRef.current !== null) {
      clearInterval(intervalRef.current);
      intervalRef.current = null;
    }
  }, []);
  return [set, clear];
}

function useLatestValue(value, dependencies) {
  if (dependencies === void 0) {
    dependencies = [value];
  }

  const valueRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(value);
  useIsomorphicLayoutEffect(() => {
    if (valueRef.current !== value) {
      valueRef.current = value;
    }
  }, dependencies);
  return valueRef;
}

function useLazyMemo(callback, dependencies) {
  const valueRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)();
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    const newValue = callback(valueRef.current);
    valueRef.current = newValue;
    return newValue;
  }, // eslint-disable-next-line react-hooks/exhaustive-deps
  [...dependencies]);
}

function useNodeRef(onChange) {
  const onChangeHandler = useEvent(onChange);
  const node = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const setNodeRef = (0,react__WEBPACK_IMPORTED_MODULE_0__.useCallback)(element => {
    if (element !== node.current) {
      onChangeHandler == null ? void 0 : onChangeHandler(element, node.current);
    }

    node.current = element;
  }, //eslint-disable-next-line
  []);
  return [node, setNodeRef];
}

function usePrevious(value) {
  const ref = (0,react__WEBPACK_IMPORTED_MODULE_0__.useRef)();
  (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
    ref.current = value;
  }, [value]);
  return ref.current;
}

let ids = {};
function useUniqueId(prefix, value) {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useMemo)(() => {
    if (value) {
      return value;
    }

    const id = ids[prefix] == null ? 0 : ids[prefix] + 1;
    ids[prefix] = id;
    return prefix + "-" + id;
  }, [prefix, value]);
}

function createAdjustmentFn(modifier) {
  return function (object) {
    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      adjustments[_key - 1] = arguments[_key];
    }

    return adjustments.reduce((accumulator, adjustment) => {
      const entries = Object.entries(adjustment);

      for (const [key, valueAdjustment] of entries) {
        const value = accumulator[key];

        if (value != null) {
          accumulator[key] = value + modifier * valueAdjustment;
        }
      }

      return accumulator;
    }, { ...object
    });
  };
}

const add = /*#__PURE__*/createAdjustmentFn(1);
const subtract = /*#__PURE__*/createAdjustmentFn(-1);

function hasViewportRelativeCoordinates(event) {
  return 'clientX' in event && 'clientY' in event;
}

function isKeyboardEvent(event) {
  if (!event) {
    return false;
  }

  const {
    KeyboardEvent
  } = getWindow(event.target);
  return KeyboardEvent && event instanceof KeyboardEvent;
}

function isTouchEvent(event) {
  if (!event) {
    return false;
  }

  const {
    TouchEvent
  } = getWindow(event.target);
  return TouchEvent && event instanceof TouchEvent;
}

/**
 * Returns the normalized x and y coordinates for mouse and touch events.
 */

function getEventCoordinates(event) {
  if (isTouchEvent(event)) {
    if (event.touches && event.touches.length) {
      const {
        clientX: x,
        clientY: y
      } = event.touches[0];
      return {
        x,
        y
      };
    } else if (event.changedTouches && event.changedTouches.length) {
      const {
        clientX: x,
        clientY: y
      } = event.changedTouches[0];
      return {
        x,
        y
      };
    }
  }

  if (hasViewportRelativeCoordinates(event)) {
    return {
      x: event.clientX,
      y: event.clientY
    };
  }

  return null;
}

const CSS = /*#__PURE__*/Object.freeze({
  Translate: {
    toString(transform) {
      if (!transform) {
        return;
      }

      const {
        x,
        y
      } = transform;
      return "translate3d(" + (x ? Math.round(x) : 0) + "px, " + (y ? Math.round(y) : 0) + "px, 0)";
    }

  },
  Scale: {
    toString(transform) {
      if (!transform) {
        return;
      }

      const {
        scaleX,
        scaleY
      } = transform;
      return "scaleX(" + scaleX + ") scaleY(" + scaleY + ")";
    }

  },
  Transform: {
    toString(transform) {
      if (!transform) {
        return;
      }

      return [CSS.Translate.toString(transform), CSS.Scale.toString(transform)].join(' ');
    }

  },
  Transition: {
    toString(_ref) {
      let {
        property,
        duration,
        easing
      } = _ref;
      return property + " " + duration + "ms " + easing;
    }

  }
});

const SELECTOR = 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]';
function findFirstFocusableNode(element) {
  if (element.matches(SELECTOR)) {
    return element;
  }

  return element.querySelector(SELECTOR);
}


//# sourceMappingURL=utilities.esm.js.map


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js":
/*!*****************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js ***!
  \*****************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ createCache; }
/* harmony export */ });
/* harmony import */ var _emotion_sheet__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/sheet */ "../../../../redfox-packages/core-components/node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Parser.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Tokenizer.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Serializer.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! stylis */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Middleware.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/weak-memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @emotion/memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");





var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
  var previous = 0;
  var character = 0;

  while (true) {
    previous = character;
    character = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)(); // &\f

    if (previous === 38 && character === 12) {
      points[index] = 1;
    }

    if ((0,stylis__WEBPACK_IMPORTED_MODULE_4__.token)(character)) {
      break;
    }

    (0,stylis__WEBPACK_IMPORTED_MODULE_4__.next)();
  }

  return (0,stylis__WEBPACK_IMPORTED_MODULE_4__.slice)(begin, stylis__WEBPACK_IMPORTED_MODULE_4__.position);
};

var toRules = function toRules(parsed, points) {
  // pretend we've started with a comma
  var index = -1;
  var character = 44;

  do {
    switch ((0,stylis__WEBPACK_IMPORTED_MODULE_4__.token)(character)) {
      case 0:
        // &\f
        if (character === 38 && (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)() === 12) {
          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
          // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
          // and when it should just concatenate the outer and inner selectors
          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
          points[index] = 1;
        }

        parsed[index] += identifierWithPointTracking(stylis__WEBPACK_IMPORTED_MODULE_4__.position - 1, points, index);
        break;

      case 2:
        parsed[index] += (0,stylis__WEBPACK_IMPORTED_MODULE_4__.delimit)(character);
        break;

      case 4:
        // comma
        if (character === 44) {
          // colon
          parsed[++index] = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)() === 58 ? '&\f' : '';
          points[index] = parsed[index].length;
          break;
        }

      // fallthrough

      default:
        parsed[index] += (0,stylis__WEBPACK_IMPORTED_MODULE_2__.from)(character);
    }
  } while (character = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.next)());

  return parsed;
};

var getRules = function getRules(value, points) {
  return (0,stylis__WEBPACK_IMPORTED_MODULE_4__.dealloc)(toRules((0,stylis__WEBPACK_IMPORTED_MODULE_4__.alloc)(value), points));
}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11


var fixedElements = /* #__PURE__ */new WeakMap();
var compat = function compat(element) {
  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
  // negative .length indicates that this rule has been already prefixed
  element.length < 1) {
    return;
  }

  var value = element.value;
  var parent = element.parent;
  var isImplicitRule = element.column === parent.column && element.line === parent.line;

  while (parent.type !== 'rule') {
    parent = parent.parent;
    if (!parent) return;
  } // short-circuit for the simplest case


  if (element.props.length === 1 && value.charCodeAt(0) !== 58
  /* colon */
  && !fixedElements.get(parent)) {
    return;
  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"


  if (isImplicitRule) {
    return;
  }

  fixedElements.set(element, true);
  var points = [];
  var rules = getRules(value, points);
  var parentRules = parent.props;

  for (var i = 0, k = 0; i < rules.length; i++) {
    for (var j = 0; j < parentRules.length; j++, k++) {
      element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
    }
  }
};
var removeLabel = function removeLabel(element) {
  if (element.type === 'decl') {
    var value = element.value;

    if ( // charcode for l
    value.charCodeAt(0) === 108 && // charcode for b
    value.charCodeAt(2) === 98) {
      // this ignores label
      element["return"] = '';
      element.value = '';
    }
  }
};
var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';

var isIgnoringComment = function isIgnoringComment(element) {
  return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1;
};

var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
  return function (element, index, children) {
    if (element.type !== 'rule' || cache.compat) return;
    var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);

    if (unsafePseudoClasses) {
      var isNested = !!element.parent; // in nested rules comments become children of the "auto-inserted" rule and that's always the `element.parent`
      //
      // considering this input:
      // .a {
      //   .b /* comm */ {}
      //   color: hotpink;
      // }
      // we get output corresponding to this:
      // .a {
      //   & {
      //     /* comm */
      //     color: hotpink;
      //   }
      //   .b {}
      // }

      var commentContainer = isNested ? element.parent.children : // global rule at the root level
      children;

      for (var i = commentContainer.length - 1; i >= 0; i--) {
        var node = commentContainer[i];

        if (node.line < element.line) {
          break;
        } // it is quite weird but comments are *usually* put at `column: element.column - 1`
        // so we seek *from the end* for the node that is earlier than the rule's `element` and check that
        // this will also match inputs like this:
        // .a {
        //   /* comm */
        //   .b {}
        // }
        //
        // but that is fine
        //
        // it would be the easiest to change the placement of the comment to be the first child of the rule:
        // .a {
        //   .b { /* comm */ }
        // }
        // with such inputs we wouldn't have to search for the comment at all
        // TODO: consider changing this comment placement in the next major version


        if (node.column < element.column) {
          if (isIgnoringComment(node)) {
            return;
          }

          break;
        }
      }

      unsafePseudoClasses.forEach(function (unsafePseudoClass) {
        console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\".");
      });
    }
  };
};

var isImportRule = function isImportRule(element) {
  return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64;
};

var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
  for (var i = index - 1; i >= 0; i--) {
    if (!isImportRule(children[i])) {
      return true;
    }
  }

  return false;
}; // use this to remove incorrect elements from further processing
// so they don't get handed to the `sheet` (or anything else)
// as that could potentially lead to additional logs which in turn could be overhelming to the user


var nullifyElement = function nullifyElement(element) {
  element.type = '';
  element.value = '';
  element["return"] = '';
  element.children = '';
  element.props = '';
};

var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
  if (!isImportRule(element)) {
    return;
  }

  if (element.parent) {
    console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles.");
    nullifyElement(element);
  } else if (isPrependedWithRegularRules(index, children)) {
    console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules.");
    nullifyElement(element);
  }
};

/* eslint-disable no-fallthrough */

function prefix(value, length) {
  switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.hash)(value, length)) {
    // color-adjust
    case 5103:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'print-' + value + value;
    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)

    case 5737:
    case 4201:
    case 3177:
    case 3433:
    case 1641:
    case 4457:
    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break

    case 5572:
    case 6356:
    case 5844:
    case 3191:
    case 6645:
    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,

    case 6391:
    case 5879:
    case 5623:
    case 6135:
    case 4599:
    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)

    case 4215:
    case 6389:
    case 5109:
    case 5365:
    case 5621:
    case 3829:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + value;
    // appearance, user-select, transform, hyphens, text-size-adjust

    case 5349:
    case 4246:
    case 4810:
    case 6968:
    case 2756:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
    // flex, flex-direction

    case 6828:
    case 4268:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
    // order

    case 6165:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-' + value + value;
    // align-items

    case 5187:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(\w+).+(:[^]+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-$1$2' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-$1$2') + value;
    // align-self

    case 5443:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-item-' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /flex-|-self/, '') + value;
    // align-content

    case 4675:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-line-pack' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /align-content|flex-|-self/, '') + value;
    // flex-shrink

    case 5548:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'shrink', 'negative') + value;
    // flex-basis

    case 5292:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'basis', 'preferred-size') + value;
    // flex-grow

    case 6060:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, '-grow', '') + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'grow', 'positive') + value;
    // transition

    case 4554:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /([^-])(transform)/g, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2') + value;
    // cursor

    case 6187:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(zoom-|grab)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1'), /(image-set)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1'), value, '') + value;
    // background, background-image

    case 5495:
    case 3959:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(image-set\([^]*)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1' + '$`$1');
    // justify-content

    case 4968:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)(flex-)?(.*)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-pack:$3' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + value;
    // (margin|padding)-inline-(start|end)

    case 4095:
    case 3583:
    case 4068:
    case 2532:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+)-inline(.+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1$2') + value;
    // (min|max)?(width|height|inline-size|block-size)

    case 8116:
    case 7059:
    case 5753:
    case 5535:
    case 5445:
    case 5701:
    case 4933:
    case 4677:
    case 5533:
    case 5789:
    case 5021:
    case 4765:
      // stretch, max-content, min-content, fill-available
      if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.strlen)(value) - 1 - length > 6) switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 1)) {
        // (m)ax-content, (m)in-content
        case 109:
          // -
          if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 4) !== 45) break;
        // (f)ill-available, (f)it-content

        case 102:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)(.+)-([^]+)/, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2-$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
        // (s)tretch

        case 115:
          return ~(0,stylis__WEBPACK_IMPORTED_MODULE_2__.indexof)(value, 'stretch') ? prefix((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'stretch', 'fill-available'), length) + value : value;
      }
      break;
    // position: sticky

    case 4949:
      // (s)ticky?
      if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 1) !== 115) break;
    // display: (flex|inline-flex)

    case 6444:
      switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, (0,stylis__WEBPACK_IMPORTED_MODULE_2__.strlen)(value) - 3 - (~(0,stylis__WEBPACK_IMPORTED_MODULE_2__.indexof)(value, '!important') && 10))) {
        // stic(k)y
        case 107:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, ':', ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT) + value;
        // (inline-)?fl(e)x

        case 101:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + '$2box$3') + value;
      }

      break;
    // writing-mode

    case 5936:
      switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 11)) {
        // vertical-l(r)
        case 114:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
        // vertical-r(l)

        case 108:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
        // horizontal(-)tb

        case 45:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
      }

      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
  }

  return value;
}

var prefixer = function prefixer(element, index, children, callback) {
  if (element.length > -1) if (!element["return"]) switch (element.type) {
    case stylis__WEBPACK_IMPORTED_MODULE_1__.DECLARATION:
      element["return"] = prefix(element.value, element.length);
      break;

    case stylis__WEBPACK_IMPORTED_MODULE_1__.KEYFRAMES:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
        value: (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(element.value, '@', '@' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT)
      })], callback);

    case stylis__WEBPACK_IMPORTED_MODULE_1__.RULESET:
      if (element.length) return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.combine)(element.props, function (value) {
        switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.match)(value, /(::plac\w+|:read-\w+)/)) {
          // :read-(only|write)
          case ':read-only':
          case ':read-write':
            return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(read-\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + '$1')]
            })], callback);
          // :placeholder

          case '::placeholder':
            return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'input-$1')]
            }), (0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + '$1')]
            }), (0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'input-$1')]
            })], callback);
        }

        return '';
      });
  }
};

var defaultStylisPlugins = [prefixer];
var getSourceMap;

{
  var sourceMapPattern = /\/\*#\ssourceMappingURL=data:application\/json;\S+\s+\*\//g;

  getSourceMap = function getSourceMap(styles) {
    var matches = styles.match(sourceMapPattern);
    if (!matches) return;
    return matches[matches.length - 1];
  };
}

var createCache = function createCache(options) {
  var key = options.key;

  if (!key) {
    throw new Error("You have to configure `key` for your cache. Please make sure it's unique (and not equal to 'css') as it's used for linking styles to your cache.\n" + "If multiple caches share the same key they might \"fight\" for each other's style elements.");
  }

  if (key === 'css') {
    var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
    // note this very very intentionally targets all style elements regardless of the key to ensure
    // that creating a cache works inside of render of a React component

    Array.prototype.forEach.call(ssrStyles, function (node) {
      // we want to only move elements which have a space in the data-emotion attribute value
      // because that indicates that it is an Emotion 11 server-side rendered style elements
      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
      // will not result in the Emotion 10 styles being destroyed
      var dataEmotionAttribute = node.getAttribute('data-emotion');

      if (dataEmotionAttribute.indexOf(' ') === -1) {
        return;
      }

      document.head.appendChild(node);
      node.setAttribute('data-s', '');
    });
  }

  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;

  {
    if (/[^a-z-]/.test(key)) {
      throw new Error("Emotion key must only contain lower case alphabetical characters and - but \"" + key + "\" was passed");
    }
  }

  var inserted = {};
  var container;
  var nodesToHydrate = [];

  {
    container = options.container || document.head;
    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
      var attrib = node.getAttribute("data-emotion").split(' ');

      for (var i = 1; i < attrib.length; i++) {
        inserted[attrib[i]] = true;
      }

      nodesToHydrate.push(node);
    });
  }

  var _insert;

  var omnipresentPlugins = [compat, removeLabel];

  {
    omnipresentPlugins.push(createUnsafeSelectorsAlarm({
      get compat() {
        return cache.compat;
      }

    }), incorrectImportAlarm);
  }

  {
    var currentSheet;
    var finalizingPlugins = [stylis__WEBPACK_IMPORTED_MODULE_5__.stringify, function (element) {
      if (!element.root) {
        if (element["return"]) {
          currentSheet.insert(element["return"]);
        } else if (element.value && element.type !== stylis__WEBPACK_IMPORTED_MODULE_1__.COMMENT) {
          // insert empty rule in non-production environments
          // so @emotion/jest can grab `key` from the (JS)DOM for caches without any rules inserted yet
          currentSheet.insert(element.value + "{}");
        }
      }
    } ];
    var serializer = (0,stylis__WEBPACK_IMPORTED_MODULE_6__.middleware)(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));

    var stylis = function stylis(styles) {
      return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)((0,stylis__WEBPACK_IMPORTED_MODULE_3__.compile)(styles), serializer);
    };

    _insert = function insert(selector, serialized, sheet, shouldCache) {
      currentSheet = sheet;

      if (getSourceMap) {
        var sourceMap = getSourceMap(serialized.styles);

        if (sourceMap) {
          currentSheet = {
            insert: function insert(rule) {
              sheet.insert(rule + sourceMap);
            }
          };
        }
      }

      stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);

      if (shouldCache) {
        cache.inserted[serialized.name] = true;
      }
    };
  }

  var cache = {
    key: key,
    sheet: new _emotion_sheet__WEBPACK_IMPORTED_MODULE_0__.StyleSheet({
      key: key,
      container: container,
      nonce: options.nonce,
      speedy: options.speedy,
      prepend: options.prepend,
      insertionPoint: options.insertionPoint
    }),
    nonce: options.nonce,
    inserted: inserted,
    registered: {},
    insert: _insert
  };
  cache.sheet.hydrate(nodesToHydrate);
  return cache;
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/hash/dist/emotion-hash.esm.js":
/*!*******************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/hash/dist/emotion-hash.esm.js ***!
  \*******************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ murmur2; }
/* harmony export */ });
/* eslint-disable */
// Inspired by https://github.com/garycourt/murmurhash-js
// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
function murmur2(str) {
  // 'm' and 'r' are mixing constants generated offline.
  // They're not really 'magic', they just happen to work well.
  // const m = 0x5bd1e995;
  // const r = 24;
  // Initialize the hash
  var h = 0; // Mix 4 bytes at a time into the hash

  var k,
      i = 0,
      len = str.length;

  for (; len >= 4; ++i, len -= 4) {
    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
    k =
    /* Math.imul(k, m): */
    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
    k ^=
    /* k >>> r: */
    k >>> 24;
    h =
    /* Math.imul(k, m): */
    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
    /* Math.imul(h, m): */
    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  } // Handle the last few bytes of the input array


  switch (len) {
    case 3:
      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;

    case 2:
      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;

    case 1:
      h ^= str.charCodeAt(i) & 0xff;
      h =
      /* Math.imul(h, m): */
      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  } // Do a few final mixes of the hash to ensure the last few
  // bytes are well-incorporated.


  h ^= h >>> 13;
  h =
  /* Math.imul(h, m): */
  (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  return ((h ^ h >>> 15) >>> 0).toString(36);
}




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js":
/*!*************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js ***!
  \*************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ isPropValid; }
/* harmony export */ });
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");


// eslint-disable-next-line no-undef
var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23

var isPropValid = /* #__PURE__ */(0,_emotion_memoize__WEBPACK_IMPORTED_MODULE_0__["default"])(function (prop) {
  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
  /* o */
  && prop.charCodeAt(1) === 110
  /* n */
  && prop.charCodeAt(2) < 91;
}
/* Z+1 */
);




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js":
/*!*************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js ***!
  \*************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ memoize; }
/* harmony export */ });
function memoize(fn) {
  var cache = Object.create(null);
  return function (arg) {
    if (cache[arg] === undefined) cache[arg] = fn(arg);
    return cache[arg];
  };
}




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js":
/*!***********************************************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js ***!
  \***********************************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ hoistNonReactStatics; }
/* harmony export */ });
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! hoist-non-react-statics */ "../../../../redfox-packages/core-components/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0__);


// this file isolates this package that is not tree-shakeable
// and if this module doesn't actually contain any logic of its own
// then Rollup just use 'hoist-non-react-statics' directly in other chunks

var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
  return hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0___default()(targetComponent, sourceComponent);
});




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js":
/*!****************************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js ***!
  \****************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   C: function() { return /* binding */ CacheProvider; },
/* harmony export */   E: function() { return /* binding */ Emotion$1; },
/* harmony export */   T: function() { return /* binding */ ThemeContext; },
/* harmony export */   _: function() { return /* binding */ __unsafe_useEmotionCache; },
/* harmony export */   a: function() { return /* binding */ ThemeProvider; },
/* harmony export */   b: function() { return /* binding */ withTheme; },
/* harmony export */   c: function() { return /* binding */ createEmotionProps; },
/* harmony export */   h: function() { return /* binding */ hasOwn; },
/* harmony export */   u: function() { return /* binding */ useTheme; },
/* harmony export */   w: function() { return /* binding */ withEmotionCache; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/cache */ "../../../../redfox-packages/core-components/node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/esm/extends */ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/weak-memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var _isolated_hnrs_dist_emotion_react_isolated_hnrs_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/utils */ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/serialize */ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");










var EmotionCacheContext = /* #__PURE__ */react__WEBPACK_IMPORTED_MODULE_0__.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
// because this module is primarily intended for the browser and node
// but it's also required in react native and similar environments sometimes
// and we could have a special build just for that
// but this is much easier and the native packages
// might use a different theme context in the future anyway
typeof HTMLElement !== 'undefined' ? /* #__PURE__ */(0,_emotion_cache__WEBPACK_IMPORTED_MODULE_1__["default"])({
  key: 'css'
}) : null);

{
  EmotionCacheContext.displayName = 'EmotionCacheContext';
}

var CacheProvider = EmotionCacheContext.Provider;
var __unsafe_useEmotionCache = function useEmotionCache() {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(EmotionCacheContext);
};

var withEmotionCache = function withEmotionCache(func) {
  return /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(function (props, ref) {
    // the cache will never be null in the browser
    var cache = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(EmotionCacheContext);
    return func(props, cache, ref);
  });
};

var ThemeContext = /* #__PURE__ */react__WEBPACK_IMPORTED_MODULE_0__.createContext({});

{
  ThemeContext.displayName = 'EmotionThemeContext';
}

var useTheme = function useTheme() {
  return react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);
};

var getTheme = function getTheme(outerTheme, theme) {
  if (typeof theme === 'function') {
    var mergedTheme = theme(outerTheme);

    if ((mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
    }

    return mergedTheme;
  }

  if ((theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
  }

  return (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__["default"])({}, outerTheme, theme);
};

var createCacheWithTheme = /* #__PURE__ */(0,_emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__["default"])(function (outerTheme) {
  return (0,_emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__["default"])(function (theme) {
    return getTheme(outerTheme, theme);
  });
});
var ThemeProvider = function ThemeProvider(props) {
  var theme = react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);

  if (props.theme !== theme) {
    theme = createCacheWithTheme(theme)(props.theme);
  }

  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(ThemeContext.Provider, {
    value: theme
  }, props.children);
};
function withTheme(Component) {
  var componentName = Component.displayName || Component.name || 'Component';
  var WithTheme = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(function render(props, ref) {
    var theme = react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);
    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Component, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__["default"])({
      theme: theme,
      ref: ref
    }, props));
  });
  WithTheme.displayName = "WithTheme(" + componentName + ")";
  return (0,_isolated_hnrs_dist_emotion_react_isolated_hnrs_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_4__["default"])(WithTheme, Component);
}

var hasOwn = {}.hasOwnProperty;

var getLastPart = function getLastPart(functionName) {
  // The match may be something like 'Object.createEmotionProps' or
  // 'Loader.prototype.render'
  var parts = functionName.split('.');
  return parts[parts.length - 1];
};

var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
  // V8
  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
  if (match) return getLastPart(match[1]); // Safari / Firefox

  match = /^([A-Za-z0-9$.]+)@/.exec(line);
  if (match) return getLastPart(match[1]);
  return undefined;
};

var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
// identifiers, thus we only need to replace what is a valid character for JS,
// but not for CSS.

var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
  return identifier.replace(/\$/g, '-');
};

var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
  if (!stackTrace) return undefined;
  var lines = stackTrace.split('\n');

  for (var i = 0; i < lines.length; i++) {
    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"

    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit

    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
    // uppercase letter

    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
  }

  return undefined;
};

var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
var createEmotionProps = function createEmotionProps(type, props) {
  if (typeof props.css === 'string' && // check if there is a css declaration
  props.css.indexOf(':') !== -1) {
    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
  }

  var newProps = {};

  for (var _key in props) {
    if (hasOwn.call(props, _key)) {
      newProps[_key] = props[_key];
    }
  }

  newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:
  // - It causes hydration warnings when using Safari and SSR
  // - It can degrade performance if there are a huge number of elements
  //
  // Even if the flag is set, we still don't compute the label if it has already
  // been determined by the Babel plugin.

  if (typeof globalThis !== 'undefined' && !!globalThis.EMOTION_RUNTIME_AUTO_LABEL && !!props.css && (typeof props.css !== 'object' || !('name' in props.css) || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
    var label = getLabelFromStackTrace(new Error().stack);
    if (label) newProps[labelPropName] = label;
  }

  return newProps;
};

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.registerStyles)(cache, serialized, isStringTag);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_7__.useInsertionEffectAlwaysWithSyncFallback)(function () {
    return (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.insertStyles)(cache, serialized, isStringTag);
  });

  return null;
};

var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
  // not passing the registered cache to serializeStyles because it would
  // make certain babel optimisations not possible

  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
    cssProp = cache.registered[cssProp];
  }

  var WrappedComponent = props[typePropName];
  var registeredStyles = [cssProp];
  var className = '';

  if (typeof props.className === 'string') {
    className = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.getRegisteredStyles)(cache.registered, registeredStyles, props.className);
  } else if (props.className != null) {
    className = props.className + " ";
  }

  var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_6__.serializeStyles)(registeredStyles, undefined, react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext));

  if (serialized.name.indexOf('-') === -1) {
    var labelFromStack = props[labelPropName];

    if (labelFromStack) {
      serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_6__.serializeStyles)([serialized, 'label:' + labelFromStack + ';']);
    }
  }

  className += cache.key + "-" + serialized.name;
  var newProps = {};

  for (var _key2 in props) {
    if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && (_key2 !== labelPropName)) {
      newProps[_key2] = props[_key2];
    }
  }

  newProps.className = className;

  if (ref) {
    newProps.ref = ref;
  }

  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Insertion, {
    cache: cache,
    serialized: serialized,
    isStringTag: typeof WrappedComponent === 'string'
  }), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(WrappedComponent, newProps));
});

{
  Emotion.displayName = 'EmotionCssPropInternal';
}

var Emotion$1 = Emotion;




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js":
/*!*****************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js ***!
  \*****************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CacheProvider: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.C; },
/* harmony export */   ClassNames: function() { return /* binding */ ClassNames; },
/* harmony export */   Global: function() { return /* binding */ Global; },
/* harmony export */   ThemeContext: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T; },
/* harmony export */   ThemeProvider: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.a; },
/* harmony export */   __unsafe_useEmotionCache: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__._; },
/* harmony export */   createElement: function() { return /* binding */ jsx; },
/* harmony export */   css: function() { return /* binding */ css; },
/* harmony export */   jsx: function() { return /* binding */ jsx; },
/* harmony export */   keyframes: function() { return /* binding */ keyframes; },
/* harmony export */   useTheme: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.u; },
/* harmony export */   withEmotionCache: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w; },
/* harmony export */   withTheme: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.b; }
/* harmony export */ });
/* harmony import */ var _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./emotion-element-489459f2.browser.development.esm.js */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/utils */ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/serialize */ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/cache */ "../../../../redfox-packages/core-components/node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/weak-memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! hoist-non-react-statics */ "../../../../redfox-packages/core-components/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8__);












var isDevelopment = true;

var pkg = {
	name: "@emotion/react",
	version: "11.14.0",
	main: "dist/emotion-react.cjs.js",
	module: "dist/emotion-react.esm.js",
	types: "dist/emotion-react.cjs.d.ts",
	exports: {
		".": {
			types: {
				"import": "./dist/emotion-react.cjs.mjs",
				"default": "./dist/emotion-react.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				worker: {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				browser: {
					module: "./dist/emotion-react.browser.development.esm.js",
					"import": "./dist/emotion-react.browser.development.cjs.mjs",
					"default": "./dist/emotion-react.browser.development.cjs.js"
				},
				module: "./dist/emotion-react.development.esm.js",
				"import": "./dist/emotion-react.development.cjs.mjs",
				"default": "./dist/emotion-react.development.cjs.js"
			},
			"edge-light": {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			worker: {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			workerd: {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			browser: {
				module: "./dist/emotion-react.browser.esm.js",
				"import": "./dist/emotion-react.browser.cjs.mjs",
				"default": "./dist/emotion-react.browser.cjs.js"
			},
			module: "./dist/emotion-react.esm.js",
			"import": "./dist/emotion-react.cjs.mjs",
			"default": "./dist/emotion-react.cjs.js"
		},
		"./jsx-runtime": {
			types: {
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				worker: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				browser: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.cjs.js"
				},
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.cjs.js"
			},
			"edge-light": {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			worker: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			workerd: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			browser: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.cjs.js"
			},
			module: "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js",
			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
		},
		"./_isolated-hnrs": {
			types: {
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				worker: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				browser: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.cjs.js"
				},
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.cjs.js"
			},
			"edge-light": {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			worker: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			workerd: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			browser: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.cjs.js"
			},
			module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js",
			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
		},
		"./jsx-dev-runtime": {
			types: {
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				worker: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				browser: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.cjs.js"
				},
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.cjs.js"
			},
			"edge-light": {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			worker: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			workerd: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			browser: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.cjs.js"
			},
			module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js",
			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
		},
		"./package.json": "./package.json",
		"./types/css-prop": "./types/css-prop.d.ts",
		"./macro": {
			types: {
				"import": "./macro.d.mts",
				"default": "./macro.d.ts"
			},
			"default": "./macro.js"
		}
	},
	imports: {
		"#is-development": {
			development: "./src/conditions/true.ts",
			"default": "./src/conditions/false.ts"
		},
		"#is-browser": {
			"edge-light": "./src/conditions/false.ts",
			workerd: "./src/conditions/false.ts",
			worker: "./src/conditions/false.ts",
			browser: "./src/conditions/true.ts",
			"default": "./src/conditions/is-browser.ts"
		}
	},
	files: [
		"src",
		"dist",
		"jsx-runtime",
		"jsx-dev-runtime",
		"_isolated-hnrs",
		"types/css-prop.d.ts",
		"macro.*"
	],
	sideEffects: false,
	author: "Emotion Contributors",
	license: "MIT",
	scripts: {
		"test:typescript": "dtslint types"
	},
	dependencies: {
		"@babel/runtime": "^7.18.3",
		"@emotion/babel-plugin": "^11.13.5",
		"@emotion/cache": "^11.14.0",
		"@emotion/serialize": "^1.3.3",
		"@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
		"@emotion/utils": "^1.4.2",
		"@emotion/weak-memoize": "^0.4.0",
		"hoist-non-react-statics": "^3.3.1"
	},
	peerDependencies: {
		react: ">=16.8.0"
	},
	peerDependenciesMeta: {
		"@types/react": {
			optional: true
		}
	},
	devDependencies: {
		"@definitelytyped/dtslint": "0.0.112",
		"@emotion/css": "11.13.5",
		"@emotion/css-prettifier": "1.2.0",
		"@emotion/server": "11.11.0",
		"@emotion/styled": "11.14.0",
		"@types/hoist-non-react-statics": "^3.3.5",
		"html-tag-names": "^1.1.2",
		react: "16.14.0",
		"svg-tag-names": "^1.1.1",
		typescript: "^5.4.5"
	},
	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
	publishConfig: {
		access: "public"
	},
	"umd:main": "dist/emotion-react.umd.min.js",
	preconstruct: {
		entrypoints: [
			"./index.ts",
			"./jsx-runtime.ts",
			"./jsx-dev-runtime.ts",
			"./_isolated-hnrs.ts"
		],
		umdName: "emotionReact",
		exports: {
			extra: {
				"./types/css-prop": "./types/css-prop.d.ts",
				"./macro": {
					types: {
						"import": "./macro.d.mts",
						"default": "./macro.d.ts"
					},
					"default": "./macro.js"
				}
			}
		}
	}
};

var jsx = function jsx(type, props) {
  // eslint-disable-next-line prefer-rest-params
  var args = arguments;

  if (props == null || !_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.h.call(props, 'css')) {
    return react__WEBPACK_IMPORTED_MODULE_1__.createElement.apply(undefined, args);
  }

  var argsLength = args.length;
  var createElementArgArray = new Array(argsLength);
  createElementArgArray[0] = _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.E;
  createElementArgArray[1] = (0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.c)(type, props);

  for (var i = 2; i < argsLength; i++) {
    createElementArgArray[i] = args[i];
  }

  return react__WEBPACK_IMPORTED_MODULE_1__.createElement.apply(null, createElementArgArray);
};

(function (_jsx) {
  var JSX;

  (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
})(jsx || (jsx = {}));

var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
// initial client-side render from SSR, use place of hydrating tag

var Global = /* #__PURE__ */(0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w)(function (props, cache) {
  if (!warnedAboutCssPropForGlobal && ( // check for className as well since the user is
  // probably using the custom createElement which
  // means it will be turned into a className prop
  // I don't really want to add it to the type since it shouldn't be used
  'className' in props && props.className || 'css' in props && props.css)) {
    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
    warnedAboutCssPropForGlobal = true;
  }

  var styles = props.styles;
  var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)([styles], undefined, react__WEBPACK_IMPORTED_MODULE_1__.useContext(_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T));
  // but it is based on a constant that will never change at runtime
  // it's effectively like having two implementations and switching them out
  // so it's not actually breaking anything


  var sheetRef = react__WEBPACK_IMPORTED_MODULE_1__.useRef();
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectWithLayoutFallback)(function () {
    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675

    var sheet = new cache.sheet.constructor({
      key: key,
      nonce: cache.sheet.nonce,
      container: cache.sheet.container,
      speedy: cache.sheet.isSpeedy
    });
    var rehydrating = false;
    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");

    if (cache.sheet.tags.length) {
      sheet.before = cache.sheet.tags[0];
    }

    if (node !== null) {
      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s

      node.setAttribute('data-emotion', key);
      sheet.hydrate([node]);
    }

    sheetRef.current = [sheet, rehydrating];
    return function () {
      sheet.flush();
    };
  }, [cache]);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectWithLayoutFallback)(function () {
    var sheetRefCurrent = sheetRef.current;
    var sheet = sheetRefCurrent[0],
        rehydrating = sheetRefCurrent[1];

    if (rehydrating) {
      sheetRefCurrent[1] = false;
      return;
    }

    if (serialized.next !== undefined) {
      // insert keyframes
      (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.insertStyles)(cache, serialized.next, true);
    }

    if (sheet.tags.length) {
      // if this doesn't exist then it will be null so the style element will be appended
      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
      sheet.before = element;
      sheet.flush();
    }

    cache.insert("", serialized, sheet, false);
  }, [cache, serialized.name]);
  return null;
});

{
  Global.displayName = 'EmotionGlobal';
}

function css() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  return (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)(args);
}

function keyframes() {
  var insertable = css.apply(void 0, arguments);
  var name = "animation-" + insertable.name;
  return {
    name: name,
    styles: "@keyframes " + name + "{" + insertable.styles + "}",
    anim: 1,
    toString: function toString() {
      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
    }
  };
}

var classnames = function classnames(args) {
  var len = args.length;
  var i = 0;
  var cls = '';

  for (; i < len; i++) {
    var arg = args[i];
    if (arg == null) continue;
    var toAdd = void 0;

    switch (typeof arg) {
      case 'boolean':
        break;

      case 'object':
        {
          if (Array.isArray(arg)) {
            toAdd = classnames(arg);
          } else {
            if (arg.styles !== undefined && arg.name !== undefined) {
              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
            }

            toAdd = '';

            for (var k in arg) {
              if (arg[k] && k) {
                toAdd && (toAdd += ' ');
                toAdd += k;
              }
            }
          }

          break;
        }

      default:
        {
          toAdd = arg;
        }
    }

    if (toAdd) {
      cls && (cls += ' ');
      cls += toAdd;
    }
  }

  return cls;
};

function merge(registered, css, className) {
  var registeredStyles = [];
  var rawClassName = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.getRegisteredStyles)(registered, registeredStyles, className);

  if (registeredStyles.length < 2) {
    return className;
  }

  return rawClassName + css(registeredStyles);
}

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serializedArr = _ref.serializedArr;
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectAlwaysWithSyncFallback)(function () {

    for (var i = 0; i < serializedArr.length; i++) {
      (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.insertStyles)(cache, serializedArr[i], false);
    }
  });

  return null;
};

var ClassNames = /* #__PURE__ */(0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w)(function (props, cache) {
  var hasRendered = false;
  var serializedArr = [];

  var css = function css() {
    if (hasRendered && isDevelopment) {
      throw new Error('css can only be used during render');
    }

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)(args, cache.registered);
    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`

    (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.registerStyles)(cache, serialized, false);
    return cache.key + "-" + serialized.name;
  };

  var cx = function cx() {
    if (hasRendered && isDevelopment) {
      throw new Error('cx can only be used during render');
    }

    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return merge(cache.registered, css, classnames(args));
  };

  var content = {
    css: css,
    cx: cx,
    theme: react__WEBPACK_IMPORTED_MODULE_1__.useContext(_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T)
  };
  var ele = props.children(content);
  hasRendered = true;
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(react__WEBPACK_IMPORTED_MODULE_1__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(Insertion, {
    cache: cache,
    serializedArr: serializedArr
  }), ele);
});

{
  ClassNames.displayName = 'EmotionClassNames';
}

{
  var isBrowser = typeof document !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked

  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';

  if (isBrowser && !isTestEnv) {
    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
    var globalContext = typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
    : isBrowser ? window : __webpack_require__.g;
    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";

    if (globalContext[globalKey]) {
      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
    }

    globalContext[globalKey] = true;
  }
}




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js":
/*!*****************************************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js ***!
  \*****************************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Fragment: function() { return /* binding */ Fragment; },
/* harmony export */   jsx: function() { return /* binding */ jsx; },
/* harmony export */   jsxs: function() { return /* binding */ jsxs; }
/* harmony export */ });
/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react/jsx-runtime */ "react/jsx-runtime");
/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../dist/emotion-element-489459f2.browser.development.esm.js */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/cache */ "../../../../redfox-packages/core-components/node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/weak-memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! hoist-non-react-statics */ "../../../../redfox-packages/core-components/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/utils */ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @emotion/serialize */ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");












var Fragment = react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment;
var jsx = function jsx(type, props, key) {
  if (!_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.h.call(props, 'css')) {
    return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx(type, props, key);
  }

  return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx(_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.E, (0,_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.c)(type, props), key);
};
var jsxs = function jsxs(type, props, key) {
  if (!_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.h.call(props, 'css')) {
    return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs(type, props, key);
  }

  return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs(_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.E, (0,_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.c)(type, props), key);
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js":
/*!*****************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js ***!
  \*****************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   serializeStyles: function() { return /* binding */ serializeStyles; }
/* harmony export */ });
/* harmony import */ var _emotion_hash__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/hash */ "../../../../redfox-packages/core-components/node_modules/@emotion/hash/dist/emotion-hash.esm.js");
/* harmony import */ var _emotion_unitless__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/unitless */ "../../../../redfox-packages/core-components/node_modules/@emotion/unitless/dist/emotion-unitless.esm.js");
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/memoize */ "../../../../redfox-packages/core-components/node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");




var isDevelopment = true;

var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
var hyphenateRegex = /[A-Z]|^ms/g;
var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;

var isCustomProperty = function isCustomProperty(property) {
  return property.charCodeAt(1) === 45;
};

var isProcessableValue = function isProcessableValue(value) {
  return value != null && typeof value !== 'boolean';
};

var processStyleName = /* #__PURE__ */(0,_emotion_memoize__WEBPACK_IMPORTED_MODULE_2__["default"])(function (styleName) {
  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
});

var processStyleValue = function processStyleValue(key, value) {
  switch (key) {
    case 'animation':
    case 'animationName':
      {
        if (typeof value === 'string') {
          return value.replace(animationRegex, function (match, p1, p2) {
            cursor = {
              name: p1,
              styles: p2,
              next: cursor
            };
            return p1;
          });
        }
      }
  }

  if (_emotion_unitless__WEBPACK_IMPORTED_MODULE_1__["default"][key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
    return value + 'px';
  }

  return value;
};

{
  var contentValuePattern = /(var|attr|counters?|url|element|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/;
  var contentValues = ['normal', 'none', 'initial', 'inherit', 'unset'];
  var oldProcessStyleValue = processStyleValue;
  var msPattern = /^-ms-/;
  var hyphenPattern = /-(.)/g;
  var hyphenatedCache = {};

  processStyleValue = function processStyleValue(key, value) {
    if (key === 'content') {
      if (typeof value !== 'string' || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '"' && value.charAt(0) !== "'")) {
        throw new Error("You seem to be using a value for 'content' without quotes, try replacing it with `content: '\"" + value + "\"'`");
      }
    }

    var processed = oldProcessStyleValue(key, value);

    if (processed !== '' && !isCustomProperty(key) && key.indexOf('-') !== -1 && hyphenatedCache[key] === undefined) {
      hyphenatedCache[key] = true;
      console.error("Using kebab-case for css properties in objects is not supported. Did you mean " + key.replace(msPattern, 'ms-').replace(hyphenPattern, function (str, _char) {
        return _char.toUpperCase();
      }) + "?");
    }

    return processed;
  };
}

var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';

function handleInterpolation(mergedProps, registered, interpolation) {
  if (interpolation == null) {
    return '';
  }

  var componentSelector = interpolation;

  if (componentSelector.__emotion_styles !== undefined) {
    if (String(componentSelector) === 'NO_COMPONENT_SELECTOR') {
      throw new Error(noComponentSelectorMessage);
    }

    return componentSelector;
  }

  switch (typeof interpolation) {
    case 'boolean':
      {
        return '';
      }

    case 'object':
      {
        var keyframes = interpolation;

        if (keyframes.anim === 1) {
          cursor = {
            name: keyframes.name,
            styles: keyframes.styles,
            next: cursor
          };
          return keyframes.name;
        }

        var serializedStyles = interpolation;

        if (serializedStyles.styles !== undefined) {
          var next = serializedStyles.next;

          if (next !== undefined) {
            // not the most efficient thing ever but this is a pretty rare case
            // and there will be very few iterations of this generally
            while (next !== undefined) {
              cursor = {
                name: next.name,
                styles: next.styles,
                next: cursor
              };
              next = next.next;
            }
          }

          var styles = serializedStyles.styles + ";";
          return styles;
        }

        return createStringFromObject(mergedProps, registered, interpolation);
      }

    case 'function':
      {
        if (mergedProps !== undefined) {
          var previousCursor = cursor;
          var result = interpolation(mergedProps);
          cursor = previousCursor;
          return handleInterpolation(mergedProps, registered, result);
        } else {
          console.error('Functions that are interpolated in css calls will be stringified.\n' + 'If you want to have a css call based on props, create a function that returns a css call like this\n' + 'let dynamicStyle = (props) => css`color: ${props.color}`\n' + 'It can be called directly with props or interpolated in a styled call like this\n' + "let SomeComponent = styled('div')`${dynamicStyle}`");
        }

        break;
      }

    case 'string':
      {
        var matched = [];
        var replaced = interpolation.replace(animationRegex, function (_match, _p1, p2) {
          var fakeVarName = "animation" + matched.length;
          matched.push("const " + fakeVarName + " = keyframes`" + p2.replace(/^@keyframes animation-\w+/, '') + "`");
          return "${" + fakeVarName + "}";
        });

        if (matched.length) {
          console.error("`keyframes` output got interpolated into plain string, please wrap it with `css`.\n\nInstead of doing this:\n\n" + [].concat(matched, ["`" + replaced + "`"]).join('\n') + "\n\nYou should wrap it with `css` like this:\n\ncss`" + replaced + "`");
        }
      }

      break;
  } // finalize string values (regular strings and functions interpolated into css calls)


  var asString = interpolation;

  if (registered == null) {
    return asString;
  }

  var cached = registered[asString];
  return cached !== undefined ? cached : asString;
}

function createStringFromObject(mergedProps, registered, obj) {
  var string = '';

  if (Array.isArray(obj)) {
    for (var i = 0; i < obj.length; i++) {
      string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
    }
  } else {
    for (var key in obj) {
      var value = obj[key];

      if (typeof value !== 'object') {
        var asString = value;

        if (registered != null && registered[asString] !== undefined) {
          string += key + "{" + registered[asString] + "}";
        } else if (isProcessableValue(asString)) {
          string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
        }
      } else {
        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {
          throw new Error(noComponentSelectorMessage);
        }

        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
          for (var _i = 0; _i < value.length; _i++) {
            if (isProcessableValue(value[_i])) {
              string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
            }
          }
        } else {
          var interpolated = handleInterpolation(mergedProps, registered, value);

          switch (key) {
            case 'animation':
            case 'animationName':
              {
                string += processStyleName(key) + ":" + interpolated + ";";
                break;
              }

            default:
              {
                if (key === 'undefined') {
                  console.error(UNDEFINED_AS_OBJECT_KEY_ERROR);
                }

                string += key + "{" + interpolated + "}";
              }
          }
        }
      }
    }
  }

  return string;
}

var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
// keyframes are stored on the SerializedStyles object as a linked list

var cursor;
function serializeStyles(args, registered, mergedProps) {
  if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
    return args[0];
  }

  var stringMode = true;
  var styles = '';
  cursor = undefined;
  var strings = args[0];

  if (strings == null || strings.raw === undefined) {
    stringMode = false;
    styles += handleInterpolation(mergedProps, registered, strings);
  } else {
    var asTemplateStringsArr = strings;

    if (asTemplateStringsArr[0] === undefined) {
      console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
    }

    styles += asTemplateStringsArr[0];
  } // we start at 1 since we've already handled the first arg


  for (var i = 1; i < args.length; i++) {
    styles += handleInterpolation(mergedProps, registered, args[i]);

    if (stringMode) {
      var templateStringsArr = strings;

      if (templateStringsArr[i] === undefined) {
        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
      }

      styles += templateStringsArr[i];
    }
  } // using a global regex with .exec is stateful so lastIndex has to be reset each time


  labelPattern.lastIndex = 0;
  var identifierName = '';
  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5

  while ((match = labelPattern.exec(styles)) !== null) {
    identifierName += '-' + match[1];
  }

  var name = (0,_emotion_hash__WEBPACK_IMPORTED_MODULE_0__["default"])(styles) + identifierName;

  {
    var devStyles = {
      name: name,
      styles: styles,
      next: cursor,
      toString: function toString() {
        return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
      }
    };
    return devStyles;
  }
}




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js":
/*!*********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js ***!
  \*********************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyleSheet: function() { return /* binding */ StyleSheet; }
/* harmony export */ });
var isDevelopment = true;

/*

Based off glamor's StyleSheet, thanks Sunil ❤️

high performance StyleSheet for css-in-js systems

- uses multiple style tags behind the scenes for millions of rules
- uses `insertRule` for appending in production for *much* faster performance

// usage

import { StyleSheet } from '@emotion/sheet'

let styleSheet = new StyleSheet({ key: '', container: document.head })

styleSheet.insert('#box { border: 1px solid red; }')
- appends a css rule into the stylesheet

styleSheet.flush()
- empties the stylesheet of all its contents

*/

function sheetForTag(tag) {
  if (tag.sheet) {
    return tag.sheet;
  } // this weirdness brought to you by firefox

  /* istanbul ignore next */


  for (var i = 0; i < document.styleSheets.length; i++) {
    if (document.styleSheets[i].ownerNode === tag) {
      return document.styleSheets[i];
    }
  } // this function should always return with a value
  // TS can't understand it though so we make it stop complaining here


  return undefined;
}

function createStyleElement(options) {
  var tag = document.createElement('style');
  tag.setAttribute('data-emotion', options.key);

  if (options.nonce !== undefined) {
    tag.setAttribute('nonce', options.nonce);
  }

  tag.appendChild(document.createTextNode(''));
  tag.setAttribute('data-s', '');
  return tag;
}

var StyleSheet = /*#__PURE__*/function () {
  // Using Node instead of HTMLElement since container may be a ShadowRoot
  function StyleSheet(options) {
    var _this = this;

    this._insertTag = function (tag) {
      var before;

      if (_this.tags.length === 0) {
        if (_this.insertionPoint) {
          before = _this.insertionPoint.nextSibling;
        } else if (_this.prepend) {
          before = _this.container.firstChild;
        } else {
          before = _this.before;
        }
      } else {
        before = _this.tags[_this.tags.length - 1].nextSibling;
      }

      _this.container.insertBefore(tag, before);

      _this.tags.push(tag);
    };

    this.isSpeedy = options.speedy === undefined ? !isDevelopment : options.speedy;
    this.tags = [];
    this.ctr = 0;
    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets

    this.key = options.key;
    this.container = options.container;
    this.prepend = options.prepend;
    this.insertionPoint = options.insertionPoint;
    this.before = null;
  }

  var _proto = StyleSheet.prototype;

  _proto.hydrate = function hydrate(nodes) {
    nodes.forEach(this._insertTag);
  };

  _proto.insert = function insert(rule) {
    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
    // it's 1 in dev because we insert source maps that map a single rule to a location
    // and you can only have one source map per style tag
    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
      this._insertTag(createStyleElement(this));
    }

    var tag = this.tags[this.tags.length - 1];

    {
      var isImportRule = rule.charCodeAt(0) === 64 && rule.charCodeAt(1) === 105;

      if (isImportRule && this._alreadyInsertedOrderInsensitiveRule) {
        // this would only cause problem in speedy mode
        // but we don't want enabling speedy to affect the observable behavior
        // so we report this error at all times
        console.error("You're attempting to insert the following rule:\n" + rule + '\n\n`@import` rules must be before all other types of rules in a stylesheet but other rules have already been inserted. Please ensure that `@import` rules are before all other rules.');
      }

      this._alreadyInsertedOrderInsensitiveRule = this._alreadyInsertedOrderInsensitiveRule || !isImportRule;
    }

    if (this.isSpeedy) {
      var sheet = sheetForTag(tag);

      try {
        // this is the ultrafast version, works across browsers
        // the big drawback is that the css won't be editable in devtools
        sheet.insertRule(rule, sheet.cssRules.length);
      } catch (e) {
        if (!/:(-moz-placeholder|-moz-focus-inner|-moz-focusring|-ms-input-placeholder|-moz-read-write|-moz-read-only|-ms-clear|-ms-expand|-ms-reveal){/.test(rule)) {
          console.error("There was a problem inserting the following rule: \"" + rule + "\"", e);
        }
      }
    } else {
      tag.appendChild(document.createTextNode(rule));
    }

    this.ctr++;
  };

  _proto.flush = function flush() {
    this.tags.forEach(function (tag) {
      var _tag$parentNode;

      return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
    });
    this.tags = [];
    this.ctr = 0;

    {
      this._alreadyInsertedOrderInsensitiveRule = false;
    }
  };

  return StyleSheet;
}();




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js":
/*!*****************************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js ***!
  \*****************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ createStyled; }
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/esm/extends */ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/serialize */ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/utils */ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/is-prop-valid */ "../../../../redfox-packages/core-components/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js");








var isDevelopment = true;

var testOmitPropsOnStringTag = _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__["default"];

var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
  return key !== 'theme';
};

var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
  return typeof tag === 'string' && // 96 is one less than the char code
  // for "a" so this is checking that
  // it's a lowercase character
  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
};
var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
  var shouldForwardProp;

  if (options) {
    var optionsShouldForwardProp = options.shouldForwardProp;
    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
    } : optionsShouldForwardProp;
  }

  if (typeof shouldForwardProp !== 'function' && isReal) {
    shouldForwardProp = tag.__emotion_forwardProp;
  }

  return shouldForwardProp;
};

var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.registerStyles)(cache, serialized, isStringTag);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectAlwaysWithSyncFallback)(function () {
    return (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.insertStyles)(cache, serialized, isStringTag);
  });

  return null;
};

var createStyled = function createStyled(tag, options) {
  {
    if (tag === undefined) {
      throw new Error('You are trying to create a styled element with an undefined component.\nYou may have forgotten to import it.');
    }
  }

  var isReal = tag.__emotion_real === tag;
  var baseTag = isReal && tag.__emotion_base || tag;
  var identifierName;
  var targetClassName;

  if (options !== undefined) {
    identifierName = options.label;
    targetClassName = options.target;
  }

  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
  var shouldUseAs = !defaultShouldForwardProp('as');
  return function () {
    // eslint-disable-next-line prefer-rest-params
    var args = arguments;
    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];

    if (identifierName !== undefined) {
      styles.push("label:" + identifierName + ";");
    }

    if (args[0] == null || args[0].raw === undefined) {
      // eslint-disable-next-line prefer-spread
      styles.push.apply(styles, args);
    } else {
      var templateStringsArr = args[0];

      if (templateStringsArr[0] === undefined) {
        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
      }

      styles.push(templateStringsArr[0]);
      var len = args.length;
      var i = 1;

      for (; i < len; i++) {
        if (templateStringsArr[i] === undefined) {
          console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
        }

        styles.push(args[i], templateStringsArr[i]);
      }
    }

    var Styled = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_1__.w)(function (props, cache, ref) {
      var FinalTag = shouldUseAs && props.as || baseTag;
      var className = '';
      var classInterpolations = [];
      var mergedProps = props;

      if (props.theme == null) {
        mergedProps = {};

        for (var key in props) {
          mergedProps[key] = props[key];
        }

        mergedProps.theme = react__WEBPACK_IMPORTED_MODULE_5__.useContext(_emotion_react__WEBPACK_IMPORTED_MODULE_1__.T);
      }

      if (typeof props.className === 'string') {
        className = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.getRegisteredStyles)(cache.registered, classInterpolations, props.className);
      } else if (props.className != null) {
        className = props.className + " ";
      }

      var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_2__.serializeStyles)(styles.concat(classInterpolations), cache.registered, mergedProps);
      className += cache.key + "-" + serialized.name;

      if (targetClassName !== undefined) {
        className += " " + targetClassName;
      }

      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
      var newProps = {};

      for (var _key in props) {
        if (shouldUseAs && _key === 'as') continue;

        if (finalShouldForwardProp(_key)) {
          newProps[_key] = props[_key];
        }
      }

      newProps.className = className;

      if (ref) {
        newProps.ref = ref;
      }

      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(react__WEBPACK_IMPORTED_MODULE_5__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(Insertion, {
        cache: cache,
        serialized: serialized,
        isStringTag: typeof FinalTag === 'string'
      }), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(FinalTag, newProps));
    });
    Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
    Styled.defaultProps = tag.defaultProps;
    Styled.__emotion_real = Styled;
    Styled.__emotion_base = baseTag;
    Styled.__emotion_styles = styles;
    Styled.__emotion_forwardProp = shouldForwardProp;
    Object.defineProperty(Styled, 'toString', {
      value: function value() {
        if (targetClassName === undefined && isDevelopment) {
          return 'NO_COMPONENT_SELECTOR';
        }

        return "." + targetClassName;
      }
    });

    Styled.withComponent = function (nextTag, nextOptions) {
      var newStyled = createStyled(nextTag, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__["default"])({}, options, nextOptions, {
        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
      }));
      return newStyled.apply(void 0, styles);
    };

    return Styled;
  };
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js":
/*!*******************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js ***!
  \*******************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ styled; }
/* harmony export */ });
/* harmony import */ var _base_dist_emotion_styled_base_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../base/dist/emotion-styled-base.browser.development.esm.js */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "../../../../redfox-packages/core-components/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/serialize */ "../../../../redfox-packages/core-components/node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/utils */ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/is-prop-valid */ "../../../../redfox-packages/core-components/node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js");









var tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];

// bind it to avoid mutating the original function
var styled = _base_dist_emotion_styled_base_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__["default"].bind(null);
tags.forEach(function (tagName) {
  styled[tagName] = styled(tagName);
});




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/unitless/dist/emotion-unitless.esm.js":
/*!***************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/unitless/dist/emotion-unitless.esm.js ***!
  \***************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ unitlessKeys; }
/* harmony export */ });
var unitlessKeys = {
  animationIterationCount: 1,
  aspectRatio: 1,
  borderImageOutset: 1,
  borderImageSlice: 1,
  borderImageWidth: 1,
  boxFlex: 1,
  boxFlexGroup: 1,
  boxOrdinalGroup: 1,
  columnCount: 1,
  columns: 1,
  flex: 1,
  flexGrow: 1,
  flexPositive: 1,
  flexShrink: 1,
  flexNegative: 1,
  flexOrder: 1,
  gridRow: 1,
  gridRowEnd: 1,
  gridRowSpan: 1,
  gridRowStart: 1,
  gridColumn: 1,
  gridColumnEnd: 1,
  gridColumnSpan: 1,
  gridColumnStart: 1,
  msGridRow: 1,
  msGridRowSpan: 1,
  msGridColumn: 1,
  msGridColumnSpan: 1,
  fontWeight: 1,
  lineHeight: 1,
  opacity: 1,
  order: 1,
  orphans: 1,
  scale: 1,
  tabSize: 1,
  widows: 1,
  zIndex: 1,
  zoom: 1,
  WebkitLineClamp: 1,
  // SVG-related properties
  fillOpacity: 1,
  floodOpacity: 1,
  stopOpacity: 1,
  strokeDasharray: 1,
  strokeDashoffset: 1,
  strokeMiterlimit: 1,
  strokeOpacity: 1,
  strokeWidth: 1
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js":
/*!*****************************************************************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js ***!
  \*****************************************************************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useInsertionEffectAlwaysWithSyncFallback: function() { return /* binding */ useInsertionEffectAlwaysWithSyncFallback; },
/* harmony export */   useInsertionEffectWithLayoutFallback: function() { return /* binding */ useInsertionEffectWithLayoutFallback; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);


var syncFallback = function syncFallback(create) {
  return create();
};

var useInsertionEffect = react__WEBPACK_IMPORTED_MODULE_0__['useInsertion' + 'Effect'] ? react__WEBPACK_IMPORTED_MODULE_0__['useInsertion' + 'Effect'] : false;
var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback;
var useInsertionEffectWithLayoutFallback = useInsertionEffect || react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect;




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js":
/*!*****************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js ***!
  \*****************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getRegisteredStyles: function() { return /* binding */ getRegisteredStyles; },
/* harmony export */   insertStyles: function() { return /* binding */ insertStyles; },
/* harmony export */   registerStyles: function() { return /* binding */ registerStyles; }
/* harmony export */ });
var isBrowser = true;

function getRegisteredStyles(registered, registeredStyles, classNames) {
  var rawClassName = '';
  classNames.split(' ').forEach(function (className) {
    if (registered[className] !== undefined) {
      registeredStyles.push(registered[className] + ";");
    } else if (className) {
      rawClassName += className + " ";
    }
  });
  return rawClassName;
}
var registerStyles = function registerStyles(cache, serialized, isStringTag) {
  var className = cache.key + "-" + serialized.name;

  if ( // we only need to add the styles to the registered cache if the
  // class name could be used further down
  // the tree but if it's a string tag, we know it won't
  // so we don't have to add it to registered cache.
  // this improves memory usage since we can avoid storing the whole style string
  (isStringTag === false || // we need to always store it if we're in compat mode and
  // in node since emotion-server relies on whether a style is in
  // the registered cache to know whether a style is global or not
  // also, note that this check will be dead code eliminated in the browser
  isBrowser === false ) && cache.registered[className] === undefined) {
    cache.registered[className] = serialized.styles;
  }
};
var insertStyles = function insertStyles(cache, serialized, isStringTag) {
  registerStyles(cache, serialized, isStringTag);
  var className = cache.key + "-" + serialized.name;

  if (cache.inserted[serialized.name] === undefined) {
    var current = serialized;

    do {
      cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);

      current = current.next;
    } while (current !== undefined);
  }
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js":
/*!***********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js ***!
  \***********************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ weakMemoize; }
/* harmony export */ });
var weakMemoize = function weakMemoize(func) {
  var cache = new WeakMap();
  return function (arg) {
    if (cache.has(arg)) {
      // Use non-null assertion because we just checked that the cache `has` it
      // This allows us to remove `undefined` from the return value
      return cache.get(arg);
    }

    var ret = func(arg);
    cache.set(arg, ret);
    return ret;
  };
};




/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/CheckIcon.js":
/*!*************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/CheckIcon.js ***!
  \*************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function CheckIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m4.5 12.75 6 6 9-13.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(CheckIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleLeftIcon.js":
/*!*************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleLeftIcon.js ***!
  \*************************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ChevronDoubleLeftIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m18.75 4.5-7.5 7.5 7.5 7.5m-6-15L5.25 12l7.5 7.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ChevronDoubleLeftIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleRightIcon.js":
/*!**************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleRightIcon.js ***!
  \**************************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ChevronDoubleRightIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m5.25 4.5 7.5 7.5-7.5 7.5m6-15 7.5 7.5-7.5 7.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ChevronDoubleRightIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDownIcon.js":
/*!*******************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDownIcon.js ***!
  \*******************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ChevronDownIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m19.5 8.25-7.5 7.5-7.5-7.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ChevronDownIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronLeftIcon.js":
/*!*******************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronLeftIcon.js ***!
  \*******************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ChevronLeftIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M15.75 19.5 8.25 12l7.5-7.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ChevronLeftIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronRightIcon.js":
/*!********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronRightIcon.js ***!
  \********************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ChevronRightIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m8.25 4.5 7.5 7.5-7.5 7.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ChevronRightIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/EyeIcon.js":
/*!***********************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/EyeIcon.js ***!
  \***********************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function EyeIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M2.036 12.322a1.012 1.012 0 0 1 0-.639C3.423 7.51 7.36 4.5 12 4.5c4.638 0 8.573 3.007 9.963 7.178.07.207.07.431 0 .639C20.577 16.49 16.64 19.5 12 19.5c-4.638 0-8.573-3.007-9.963-7.178Z"
  }), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M15 12a3 3 0 1 1-6 0 3 3 0 0 1 6 0Z"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(EyeIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/MagnifyingGlassIcon.js":
/*!***********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/MagnifyingGlassIcon.js ***!
  \***********************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function MagnifyingGlassIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m21 21-5.197-5.197m0 0A7.5 7.5 0 1 0 5.196 5.196a7.5 7.5 0 0 0 10.607 10.607Z"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(MagnifyingGlassIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PencilIcon.js":
/*!**************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PencilIcon.js ***!
  \**************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function PencilIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m16.862 4.487 1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L6.832 19.82a4.5 4.5 0 0 1-1.897 1.13l-2.685.8.8-2.685a4.5 4.5 0 0 1 1.13-1.897L16.863 4.487Zm0 0L19.5 7.125"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(PencilIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PlusIcon.js":
/*!************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PlusIcon.js ***!
  \************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function PlusIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M12 4.5v15m7.5-7.5h-15"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(PlusIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/Square2StackIcon.js":
/*!********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/Square2StackIcon.js ***!
  \********************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function Square2StackIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M16.5 8.25V6a2.25 2.25 0 0 0-2.25-2.25H6A2.25 2.25 0 0 0 3.75 6v8.25A2.25 2.25 0 0 0 6 16.5h2.25m8.25-8.25H18a2.25 2.25 0 0 1 2.25 2.25V18A2.25 2.25 0 0 1 18 20.25h-7.5A2.25 2.25 0 0 1 8.25 18v-1.5m8.25-8.25h-6a2.25 2.25 0 0 0-2.25 2.25v6"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(Square2StackIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/TrashIcon.js":
/*!*************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/TrashIcon.js ***!
  \*************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function TrashIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m14.74 9-.346 9m-4.788 0L9.26 9m9.968-3.21c.342.052.682.107 1.022.166m-1.022-.165L18.16 19.673a2.25 2.25 0 0 1-2.244 2.077H8.084a2.25 2.25 0 0 1-2.244-2.077L4.772 5.79m14.456 0a48.108 48.108 0 0 0-3.478-.397m-12 .562c.34-.059.68-.114 1.022-.165m0 0a48.11 48.11 0 0 1 3.478-.397m7.5 0v-.916c0-1.18-.91-2.164-2.09-2.201a51.964 51.964 0 0 0-3.32 0c-1.18.037-2.09 1.022-2.09 2.201v.916m7.5 0a48.667 48.667 0 0 0-7.5 0"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(TrashIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/XMarkIcon.js":
/*!*************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/XMarkIcon.js ***!
  \*************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function XMarkIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M6 18 18 6M6 6l12 12"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(XMarkIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/CheckCircleIcon.js":
/*!*****************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/CheckCircleIcon.js ***!
  \*****************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function CheckCircleIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    fill: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    fillRule: "evenodd",
    d: "M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm13.36-1.814a.75.75 0 1 0-1.22-.872l-3.236 4.53L9.53 12.22a.75.75 0 0 0-1.06 1.06l2.25 2.25a.75.75 0 0 0 1.14-.094l3.75-5.25Z",
    clipRule: "evenodd"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(CheckCircleIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/ExclamationTriangleIcon.js":
/*!*************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/ExclamationTriangleIcon.js ***!
  \*************************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ExclamationTriangleIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    fill: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    fillRule: "evenodd",
    d: "M9.401 3.003c1.155-2 4.043-2 5.197 0l7.355 12.748c1.154 2-.29 4.5-2.599 4.5H4.645c-2.309 0-3.752-2.5-2.598-4.5L9.4 3.003ZM12 8.25a.75.75 0 0 1 .75.75v3.75a.75.75 0 0 1-1.5 0V9a.75.75 0 0 1 .75-.75Zm0 8.25a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z",
    clipRule: "evenodd"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ExclamationTriangleIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/InformationCircleIcon.js":
/*!***********************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/InformationCircleIcon.js ***!
  \***********************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function InformationCircleIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    fill: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    fillRule: "evenodd",
    d: "M2.25 12c0-5.385 4.365-9.75 9.75-9.75s9.75 4.365 9.75 9.75-4.365 9.75-9.75 9.75S2.25 17.385 2.25 12Zm8.706-1.442c1.146-.573 2.437.463 2.126 1.706l-.709 2.836.042-.02a.75.75 0 0 1 .67 1.34l-.04.022c-1.147.573-2.438-.463-2.127-1.706l.71-2.836-.042.02a.75.75 0 1 1-.671-1.34l.041-.022ZM12 9a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Z",
    clipRule: "evenodd"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(InformationCircleIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XCircleIcon.js":
/*!*************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XCircleIcon.js ***!
  \*************************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function XCircleIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    fill: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    fillRule: "evenodd",
    d: "M12 2.25c-5.385 0-9.75 4.365-9.75 9.75s4.365 9.75 9.75 9.75 9.75-4.365 9.75-9.75S17.385 2.25 12 2.25Zm-1.72 6.97a.75.75 0 1 0-1.06 1.06L10.94 12l-1.72 1.72a.75.75 0 1 0 1.06 1.06L12 13.06l1.72 1.72a.75.75 0 1 0 1.06-1.06L13.06 12l1.72-1.72a.75.75 0 1 0-1.06-1.06L12 10.94l-1.72-1.72Z",
    clipRule: "evenodd"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(XCircleIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XMarkIcon.js":
/*!***********************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XMarkIcon.js ***!
  \***********************************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function XMarkIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    viewBox: "0 0 24 24",
    fill: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    fillRule: "evenodd",
    d: "M5.47 5.47a.75.75 0 0 1 1.06 0L12 10.94l5.47-5.47a.75.75 0 1 1 1.06 1.06L13.06 12l5.47 5.47a.75.75 0 1 1-1.06 1.06L12 13.06l-5.47 5.47a.75.75 0 0 1-1.06-1.06L10.94 12 5.47 6.53a.75.75 0 0 1 0-1.06Z",
    clipRule: "evenodd"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(XMarkIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js":
/*!****************************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js ***!
  \****************************************************************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



var reactIs = __webpack_require__(/*! react-is */ "../../../../redfox-packages/core-components/node_modules/react-is/index.js");

/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */
var REACT_STATICS = {
  childContextTypes: true,
  contextType: true,
  contextTypes: true,
  defaultProps: true,
  displayName: true,
  getDefaultProps: true,
  getDerivedStateFromError: true,
  getDerivedStateFromProps: true,
  mixins: true,
  propTypes: true,
  type: true
};
var KNOWN_STATICS = {
  name: true,
  length: true,
  prototype: true,
  caller: true,
  callee: true,
  arguments: true,
  arity: true
};
var FORWARD_REF_STATICS = {
  '$$typeof': true,
  render: true,
  defaultProps: true,
  displayName: true,
  propTypes: true
};
var MEMO_STATICS = {
  '$$typeof': true,
  compare: true,
  defaultProps: true,
  displayName: true,
  propTypes: true,
  type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

function getStatics(component) {
  // React v16.11 and below
  if (reactIs.isMemo(component)) {
    return MEMO_STATICS;
  } // React v16.12 and above


  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}

var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
  if (typeof sourceComponent !== 'string') {
    // don't hoist over string (html) components
    if (objectPrototype) {
      var inheritedComponent = getPrototypeOf(sourceComponent);

      if (inheritedComponent && inheritedComponent !== objectPrototype) {
        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
      }
    }

    var keys = getOwnPropertyNames(sourceComponent);

    if (getOwnPropertySymbols) {
      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
    }

    var targetStatics = getStatics(targetComponent);
    var sourceStatics = getStatics(sourceComponent);

    for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];

      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

        try {
          // Avoid failures from read-only properties
          defineProperty(targetComponent, key, descriptor);
        } catch (e) {}
      }
    }
  }

  return targetComponent;
}

module.exports = hoistNonReactStatics;


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/react-is/cjs/react-is.development.js":
/*!*****************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/react-is/cjs/react-is.development.js ***!
  \*****************************************************************************************************/
/***/ (function(__unused_webpack_module, exports) {

/** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */





if (true) {
  (function() {
'use strict';

// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?

var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}

function typeOf(object) {
  if (typeof object === 'object' && object !== null) {
    var $$typeof = object.$$typeof;

    switch ($$typeof) {
      case REACT_ELEMENT_TYPE:
        var type = object.type;

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
          case REACT_CONCURRENT_MODE_TYPE:
          case REACT_FRAGMENT_TYPE:
          case REACT_PROFILER_TYPE:
          case REACT_STRICT_MODE_TYPE:
          case REACT_SUSPENSE_TYPE:
            return type;

          default:
            var $$typeofType = type && type.$$typeof;

            switch ($$typeofType) {
              case REACT_CONTEXT_TYPE:
              case REACT_FORWARD_REF_TYPE:
              case REACT_LAZY_TYPE:
              case REACT_MEMO_TYPE:
              case REACT_PROVIDER_TYPE:
                return $$typeofType;

              default:
                return $$typeof;
            }

        }

      case REACT_PORTAL_TYPE:
        return $$typeof;
    }
  }

  return undefined;
} // AsyncMode is deprecated along with isAsyncMode

var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

function isAsyncMode(object) {
  {
    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
    }
  }

  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
  return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
  return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
  return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
  return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
  return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
  return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
  return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
  return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
  return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
  return typeOf(object) === REACT_SUSPENSE_TYPE;
}

exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
  })();
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/react-is/index.js":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/react-is/index.js ***!
  \**********************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



if (false) // removed by dead control flow
{} else {
  module.exports = __webpack_require__(/*! ./cjs/react-is.development.js */ "../../../../redfox-packages/core-components/node_modules/react-is/cjs/react-is.development.js");
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js":
/*!***********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CHARSET: function() { return /* binding */ CHARSET; },
/* harmony export */   COMMENT: function() { return /* binding */ COMMENT; },
/* harmony export */   COUNTER_STYLE: function() { return /* binding */ COUNTER_STYLE; },
/* harmony export */   DECLARATION: function() { return /* binding */ DECLARATION; },
/* harmony export */   DOCUMENT: function() { return /* binding */ DOCUMENT; },
/* harmony export */   FONT_FACE: function() { return /* binding */ FONT_FACE; },
/* harmony export */   FONT_FEATURE_VALUES: function() { return /* binding */ FONT_FEATURE_VALUES; },
/* harmony export */   IMPORT: function() { return /* binding */ IMPORT; },
/* harmony export */   KEYFRAMES: function() { return /* binding */ KEYFRAMES; },
/* harmony export */   LAYER: function() { return /* binding */ LAYER; },
/* harmony export */   MEDIA: function() { return /* binding */ MEDIA; },
/* harmony export */   MOZ: function() { return /* binding */ MOZ; },
/* harmony export */   MS: function() { return /* binding */ MS; },
/* harmony export */   NAMESPACE: function() { return /* binding */ NAMESPACE; },
/* harmony export */   PAGE: function() { return /* binding */ PAGE; },
/* harmony export */   RULESET: function() { return /* binding */ RULESET; },
/* harmony export */   SUPPORTS: function() { return /* binding */ SUPPORTS; },
/* harmony export */   VIEWPORT: function() { return /* binding */ VIEWPORT; },
/* harmony export */   WEBKIT: function() { return /* binding */ WEBKIT; }
/* harmony export */ });
var MS = '-ms-'
var MOZ = '-moz-'
var WEBKIT = '-webkit-'

var COMMENT = 'comm'
var RULESET = 'rule'
var DECLARATION = 'decl'

var PAGE = '@page'
var MEDIA = '@media'
var IMPORT = '@import'
var CHARSET = '@charset'
var VIEWPORT = '@viewport'
var SUPPORTS = '@supports'
var DOCUMENT = '@document'
var NAMESPACE = '@namespace'
var KEYFRAMES = '@keyframes'
var FONT_FACE = '@font-face'
var COUNTER_STYLE = '@counter-style'
var FONT_FEATURE_VALUES = '@font-feature-values'
var LAYER = '@layer'


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Middleware.js":
/*!*****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Middleware.js ***!
  \*****************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   middleware: function() { return /* binding */ middleware; },
/* harmony export */   namespace: function() { return /* binding */ namespace; },
/* harmony export */   prefixer: function() { return /* binding */ prefixer; },
/* harmony export */   rulesheet: function() { return /* binding */ rulesheet; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");
/* harmony import */ var _Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Tokenizer.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Tokenizer.js");
/* harmony import */ var _Serializer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Serializer.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Serializer.js");
/* harmony import */ var _Prefixer_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Prefixer.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Prefixer.js");






/**
 * @param {function[]} collection
 * @return {function}
 */
function middleware (collection) {
	var length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(collection)

	return function (element, index, children, callback) {
		var output = ''

		for (var i = 0; i < length; i++)
			output += collection[i](element, index, children, callback) || ''

		return output
	}
}

/**
 * @param {function} callback
 * @return {function}
 */
function rulesheet (callback) {
	return function (element) {
		if (!element.root)
			if (element = element.return)
				callback(element)
	}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 */
function prefixer (element, index, children, callback) {
	if (element.length > -1)
		if (!element.return)
			switch (element.type) {
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION: element.return = (0,_Prefixer_js__WEBPACK_IMPORTED_MODULE_4__.prefix)(element.value, element.length, children)
					return
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.KEYFRAMES:
					return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {value: (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(element.value, '@', '@' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT)})], callback)
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET:
					if (element.length)
						return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.combine)(element.props, function (value) {
							switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /(::plac\w+|:read-\w+)/)) {
								// :read-(only|write)
								case ':read-only': case ':read-write':
									return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(read-\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + '$1')]})], callback)
								// :placeholder
								case '::placeholder':
									return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'input-$1')]}),
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + '$1')]}),
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'input-$1')]})
									], callback)
							}

							return ''
						})
			}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 */
function namespace (element) {
	switch (element.type) {
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET:
			element.props = element.props.map(function (value) {
				return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.combine)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.tokenize)(value), function (value, index, children) {
					switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 0)) {
						// \f
						case 12:
							return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 1, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(value))
						// \0 ( + > ~
						case 0: case 40: case 43: case 62: case 126:
							return value
						// :
						case 58:
							if (children[++index] === 'global')
								children[index] = '', children[++index] = '\f' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(children[index], index = 1, -1)
						// \s
						case 32:
							return index === 1 ? '' : value
						default:
							switch (index) {
								case 0: element = value
									return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children) > 1 ? '' : value
								case index = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children) - 1: case 2:
									return index === 2 ? value + element + element : value + element
								default:
									return value
							}
					}
				})
			})
	}
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Parser.js":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Parser.js ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   comment: function() { return /* binding */ comment; },
/* harmony export */   compile: function() { return /* binding */ compile; },
/* harmony export */   declaration: function() { return /* binding */ declaration; },
/* harmony export */   parse: function() { return /* binding */ parse; },
/* harmony export */   ruleset: function() { return /* binding */ ruleset; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");
/* harmony import */ var _Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Tokenizer.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Tokenizer.js");




/**
 * @param {string} value
 * @return {object[]}
 */
function compile (value) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.dealloc)(parse('', null, null, null, [''], value = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.alloc)(value), 0, [0], value))
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {string[]} rule
 * @param {string[]} rules
 * @param {string[]} rulesets
 * @param {number[]} pseudo
 * @param {number[]} points
 * @param {string[]} declarations
 * @return {object}
 */
function parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
	var index = 0
	var offset = 0
	var length = pseudo
	var atrule = 0
	var property = 0
	var previous = 0
	var variable = 1
	var scanning = 1
	var ampersand = 1
	var character = 0
	var type = ''
	var props = rules
	var children = rulesets
	var reference = rule
	var characters = type

	while (scanning)
		switch (previous = character, character = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)()) {
			// (
			case 40:
				if (previous != 108 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(characters, length - 1) == 58) {
					if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(characters += (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)(character), '&', '&\f'), '&\f') != -1)
						ampersand = -1
					break
				}
			// " ' [
			case 34: case 39: case 91:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)(character)
				break
			// \t \n \r \s
			case 9: case 10: case 13: case 32:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.whitespace)(previous)
				break
			// \
			case 92:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.escaping)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)() - 1, 7)
				continue
			// /
			case 47:
				switch ((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)()) {
					case 42: case 47:
						;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(comment((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.commenter)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)(), (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)()), root, parent), declarations)
						break
					default:
						characters += '/'
				}
				break
			// {
			case 123 * variable:
				points[index++] = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) * ampersand
			// } ; \0
			case 125 * variable: case 59: case 0:
				switch (character) {
					// \0 }
					case 0: case 125: scanning = 0
					// ;
					case 59 + offset: if (ampersand == -1) characters = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(characters, /\f/g, '')
						if (property > 0 && ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) - length))
							(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(characters, ' ', '') + ';', rule, parent, length - 2), declarations)
						break
					// @ ;
					case 59: characters += ';'
					// { rule/at-rule
					default:
						;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)

						if (character === 123)
							if (offset === 0)
								parse(characters, root, reference, reference, props, rulesets, length, points, children)
							else
								switch (atrule === 99 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(characters, 3) === 110 ? 100 : atrule) {
									// d l m s
									case 100: case 108: case 109: case 115:
										parse(value, reference, reference, rule && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)
										break
									default:
										parse(characters, reference, reference, reference, [''], children, 0, points, children)
								}
				}

				index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo
				break
			// :
			case 58:
				length = 1 + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters), property = previous
			default:
				if (variable < 1)
					if (character == 123)
						--variable
					else if (character == 125 && variable++ == 0 && (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.prev)() == 125)
						continue

				switch (characters += (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.from)(character), character * variable) {
					// &
					case 38:
						ampersand = offset > 0 ? 1 : (characters += '\f', -1)
						break
					// ,
					case 44:
						points[index++] = ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) - 1) * ampersand, ampersand = 1
						break
					// @
					case 64:
						// -
						if ((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)() === 45)
							characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)())

						atrule = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)(), offset = length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(type = characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.identifier)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)())), character++
						break
					// -
					case 45:
						if (previous === 45 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) == 2)
							variable = 0
				}
		}

	return rulesets
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} index
 * @param {number} offset
 * @param {string[]} rules
 * @param {number[]} points
 * @param {string} type
 * @param {string[]} props
 * @param {string[]} children
 * @param {number} length
 * @return {object}
 */
function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
	var post = offset - 1
	var rule = offset === 0 ? rules : ['']
	var size = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(rule)

	for (var i = 0, j = 0, k = 0; i < index; ++i)
		for (var x = 0, y = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, post + 1, post = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.abs)(j = points[i])), z = value; x < size; ++x)
			if (z = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.trim)(j > 0 ? rule[x] + ' ' + y : (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(y, /&\f/g, rule[x])))
				props[k++] = z

	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, offset === 0 ? _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET : type, props, children, length)
}

/**
 * @param {number} value
 * @param {object} root
 * @param {object?} parent
 * @return {object}
 */
function comment (value, root, parent) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.COMMENT, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.from)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.char)()), (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 2, -2), 0)
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} length
 * @return {object}
 */
function declaration (value, root, parent, length) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 0, length), (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, length + 1, -1), length)
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Prefixer.js":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Prefixer.js ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   prefix: function() { return /* binding */ prefix; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");



/**
 * @param {string} value
 * @param {number} length
 * @param {object[]} children
 * @return {string}
 */
function prefix (value, length, children) {
	switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.hash)(value, length)) {
		// color-adjust
		case 5103:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'print-' + value + value
		// animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
		case 5737: case 4201: case 3177: case 3433: case 1641: case 4457: case 2921:
		// text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
		case 5572: case 6356: case 5844: case 3191: case 6645: case 3005:
		// mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
		case 6391: case 5879: case 5623: case 6135: case 4599: case 4855:
		// background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
		case 4215: case 6389: case 5109: case 5365: case 5621: case 3829:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + value
		// tab-size
		case 4789:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + value + value
		// appearance, user-select, transform, hyphens, text-size-adjust
		case 5349: case 4246: case 4810: case 6968: case 2756:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + value + value
		// writing-mode
		case 5936:
			switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 11)) {
				// vertical-l(r)
				case 114:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb') + value
				// vertical-r(l)
				case 108:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value
				// horizontal(-)tb
				case 45:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'lr') + value
				// default: fallthrough to below
			}
		// flex, flex-direction, scroll-snap-type, writing-mode
		case 6828: case 4268: case 2903:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + value + value
		// order
		case 6165:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-' + value + value
		// align-items
		case 5187:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(\w+).+(:[^]+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-$1$2' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-$1$2') + value
		// align-self
		case 5443:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-item-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /flex-|-self/g, '') + (!(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /flex-|baseline/) ? _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-row-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /flex-|-self/g, '') : '') + value
		// align-content
		case 4675:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-line-pack' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /align-content|flex-|-self/g, '') + value
		// flex-shrink
		case 5548:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'shrink', 'negative') + value
		// flex-basis
		case 5292:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'basis', 'preferred-size') + value
		// flex-grow
		case 6060:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-grow', '') + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'grow', 'positive') + value
		// transition
		case 4554:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /([^-])(transform)/g, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2') + value
		// cursor
		case 6187:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(zoom-|grab)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1'), /(image-set)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1'), value, '') + value
		// background, background-image
		case 5495: case 3959:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(image-set\([^]*)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1' + '$`$1')
		// justify-content
		case 4968:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)(flex-)?(.*)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-pack:$3' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + value
		// justify-self
		case 4200:
			if (!(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /flex-|baseline/)) return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-column-align' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, length) + value
			break
		// grid-template-(columns|rows)
		case 2592: case 3360:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'template-', '') + value
		// grid-(row|column)-start
		case 4384: case 3616:
			if (children && children.some(function (element, index) { return length = index, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(element.props, /grid-\w+-end/) })) {
				return ~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(value + (children = children[length].value), 'span') ? value : (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-start', '') + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-row-span:' + (~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(children, 'span') ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(children, /\d+/) : +(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(children, /\d+/) - +(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /\d+/)) + ';')
			}
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-start', '') + value
		// grid-(row|column)-end
		case 4896: case 4128:
			return (children && children.some(function (element) { return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(element.props, /grid-\w+-start/) })) ? value : _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-end', '-span'), 'span ', '') + value
		// (margin|padding)-inline-(start|end)
		case 4095: case 3583: case 4068: case 2532:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+)-inline(.+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1$2') + value
		// (min|max)?(width|height|inline-size|block-size)
		case 8116: case 7059: case 5753: case 5535:
		case 5445: case 5701: case 4933: case 4677:
		case 5533: case 5789: case 5021: case 4765:
			// stretch, max-content, min-content, fill-available
			if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(value) - 1 - length > 6)
				switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 1)) {
					// (m)ax-content, (m)in-content
					case 109:
						// -
						if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 4) !== 45)
							break
					// (f)ill-available, (f)it-content
					case 102:
						return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)(.+)-([^]+)/, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2-$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 3) == 108 ? '$3' : '$2-$3')) + value
					// (s)tretch
					case 115:
						return ~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(value, 'stretch') ? prefix((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'stretch', 'fill-available'), length, children) + value : value
				}
			break
		// grid-(column|row)
		case 5152: case 5920:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/, function (_, a, b, c, d, e, f) { return (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + a + ':' + b + f) + (c ? (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + a + '-span:' + (d ? e : +e - +b)) + f : '') + value })
		// position: sticky
		case 4949:
			// stick(y)?
			if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 6) === 121)
				return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, ':', ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT) + value
			break
		// display: (flex|inline-flex|grid|inline-grid)
		case 6444:
			switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 14) === 45 ? 18 : 11)) {
				// (inline-)?fle(x)
				case 120:
					return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)([^;\s!]+)(;|(\s+)?!.+)?/, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + '$2box$3') + value
				// (inline-)?gri(d)
				case 100:
					return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, ':', ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS) + value
			}
			break
		// scroll-margin, scroll-margin-(top|right|bottom|left)
		case 5719: case 2647: case 2135: case 3927: case 2391:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'scroll-', 'scroll-snap-') + value
	}

	return value
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Serializer.js":
/*!*****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Serializer.js ***!
  \*****************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   serialize: function() { return /* binding */ serialize; },
/* harmony export */   stringify: function() { return /* binding */ stringify; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");



/**
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function serialize (children, callback) {
	var output = ''
	var length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children)

	for (var i = 0; i < length; i++)
		output += callback(children[i], i, children, callback) || ''

	return output
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function stringify (element, index, children, callback) {
	switch (element.type) {
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.LAYER: if (element.children.length) break
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.IMPORT: case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION: return element.return = element.return || element.value
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.COMMENT: return ''
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.KEYFRAMES: return element.return = element.value + '{' + serialize(element.children, callback) + '}'
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET: element.value = element.props.join(',')
	}

	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Tokenizer.js":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Tokenizer.js ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   alloc: function() { return /* binding */ alloc; },
/* harmony export */   caret: function() { return /* binding */ caret; },
/* harmony export */   char: function() { return /* binding */ char; },
/* harmony export */   character: function() { return /* binding */ character; },
/* harmony export */   characters: function() { return /* binding */ characters; },
/* harmony export */   column: function() { return /* binding */ column; },
/* harmony export */   commenter: function() { return /* binding */ commenter; },
/* harmony export */   copy: function() { return /* binding */ copy; },
/* harmony export */   dealloc: function() { return /* binding */ dealloc; },
/* harmony export */   delimit: function() { return /* binding */ delimit; },
/* harmony export */   delimiter: function() { return /* binding */ delimiter; },
/* harmony export */   escaping: function() { return /* binding */ escaping; },
/* harmony export */   identifier: function() { return /* binding */ identifier; },
/* harmony export */   length: function() { return /* binding */ length; },
/* harmony export */   line: function() { return /* binding */ line; },
/* harmony export */   next: function() { return /* binding */ next; },
/* harmony export */   node: function() { return /* binding */ node; },
/* harmony export */   peek: function() { return /* binding */ peek; },
/* harmony export */   position: function() { return /* binding */ position; },
/* harmony export */   prev: function() { return /* binding */ prev; },
/* harmony export */   slice: function() { return /* binding */ slice; },
/* harmony export */   token: function() { return /* binding */ token; },
/* harmony export */   tokenize: function() { return /* binding */ tokenize; },
/* harmony export */   tokenizer: function() { return /* binding */ tokenizer; },
/* harmony export */   whitespace: function() { return /* binding */ whitespace; }
/* harmony export */ });
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Utility.js */ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js");


var line = 1
var column = 1
var length = 0
var position = 0
var character = 0
var characters = ''

/**
 * @param {string} value
 * @param {object | null} root
 * @param {object | null} parent
 * @param {string} type
 * @param {string[] | string} props
 * @param {object[] | string} children
 * @param {number} length
 */
function node (value, root, parent, type, props, children, length) {
	return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
}

/**
 * @param {object} root
 * @param {object} props
 * @return {object}
 */
function copy (root, props) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.assign)(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
}

/**
 * @return {number}
 */
function char () {
	return character
}

/**
 * @return {number}
 */
function prev () {
	character = position > 0 ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, --position) : 0

	if (column--, character === 10)
		column = 1, line--

	return character
}

/**
 * @return {number}
 */
function next () {
	character = position < length ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, position++) : 0

	if (column++, character === 10)
		column = 1, line++

	return character
}

/**
 * @return {number}
 */
function peek () {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, position)
}

/**
 * @return {number}
 */
function caret () {
	return position
}

/**
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function slice (begin, end) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.substr)(characters, begin, end)
}

/**
 * @param {number} type
 * @return {number}
 */
function token (type) {
	switch (type) {
		// \0 \t \n \r \s whitespace token
		case 0: case 9: case 10: case 13: case 32:
			return 5
		// ! + , / > @ ~ isolate token
		case 33: case 43: case 44: case 47: case 62: case 64: case 126:
		// ; { } breakpoint token
		case 59: case 123: case 125:
			return 4
		// : accompanied token
		case 58:
			return 3
		// " ' ( [ opening delimit token
		case 34: case 39: case 40: case 91:
			return 2
		// ) ] closing delimit token
		case 41: case 93:
			return 1
	}

	return 0
}

/**
 * @param {string} value
 * @return {any[]}
 */
function alloc (value) {
	return line = column = 1, length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.strlen)(characters = value), position = 0, []
}

/**
 * @param {any} value
 * @return {any}
 */
function dealloc (value) {
	return characters = '', value
}

/**
 * @param {number} type
 * @return {string}
 */
function delimit (type) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.trim)(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
}

/**
 * @param {string} value
 * @return {string[]}
 */
function tokenize (value) {
	return dealloc(tokenizer(alloc(value)))
}

/**
 * @param {number} type
 * @return {string}
 */
function whitespace (type) {
	while (character = peek())
		if (character < 33)
			next()
		else
			break

	return token(type) > 2 || token(character) > 3 ? '' : ' '
}

/**
 * @param {string[]} children
 * @return {string[]}
 */
function tokenizer (children) {
	while (next())
		switch (token(character)) {
			case 0: (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)(identifier(position - 1), children)
				break
			case 2: ;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)(delimit(character), children)
				break
			default: ;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.from)(character), children)
		}

	return children
}

/**
 * @param {number} index
 * @param {number} count
 * @return {string}
 */
function escaping (index, count) {
	while (--count && next())
		// not 0-9 A-F a-f
		if (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))
			break

	return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
}

/**
 * @param {number} type
 * @return {number}
 */
function delimiter (type) {
	while (next())
		switch (character) {
			// ] ) " '
			case type:
				return position
			// " '
			case 34: case 39:
				if (type !== 34 && type !== 39)
					delimiter(character)
				break
			// (
			case 40:
				if (type === 41)
					delimiter(type)
				break
			// \
			case 92:
				next()
				break
		}

	return position
}

/**
 * @param {number} type
 * @param {number} index
 * @return {number}
 */
function commenter (type, index) {
	while (next())
		// //
		if (type + character === 47 + 10)
			break
		// /*
		else if (type + character === 42 + 42 && peek() === 47)
			break

	return '/*' + slice(index, position - 1) + '*' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.from)(type === 47 ? type : next())
}

/**
 * @param {number} index
 * @return {string}
 */
function identifier (index) {
	while (!token(peek()))
		next()

	return slice(index, position)
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/node_modules/stylis/src/Utility.js ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   abs: function() { return /* binding */ abs; },
/* harmony export */   append: function() { return /* binding */ append; },
/* harmony export */   assign: function() { return /* binding */ assign; },
/* harmony export */   charat: function() { return /* binding */ charat; },
/* harmony export */   combine: function() { return /* binding */ combine; },
/* harmony export */   from: function() { return /* binding */ from; },
/* harmony export */   hash: function() { return /* binding */ hash; },
/* harmony export */   indexof: function() { return /* binding */ indexof; },
/* harmony export */   match: function() { return /* binding */ match; },
/* harmony export */   replace: function() { return /* binding */ replace; },
/* harmony export */   sizeof: function() { return /* binding */ sizeof; },
/* harmony export */   strlen: function() { return /* binding */ strlen; },
/* harmony export */   substr: function() { return /* binding */ substr; },
/* harmony export */   trim: function() { return /* binding */ trim; }
/* harmony export */ });
/**
 * @param {number}
 * @return {number}
 */
var abs = Math.abs

/**
 * @param {number}
 * @return {string}
 */
var from = String.fromCharCode

/**
 * @param {object}
 * @return {object}
 */
var assign = Object.assign

/**
 * @param {string} value
 * @param {number} length
 * @return {number}
 */
function hash (value, length) {
	return charat(value, 0) ^ 45 ? (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3) : 0
}

/**
 * @param {string} value
 * @return {string}
 */
function trim (value) {
	return value.trim()
}

/**
 * @param {string} value
 * @param {RegExp} pattern
 * @return {string?}
 */
function match (value, pattern) {
	return (value = pattern.exec(value)) ? value[0] : value
}

/**
 * @param {string} value
 * @param {(string|RegExp)} pattern
 * @param {string} replacement
 * @return {string}
 */
function replace (value, pattern, replacement) {
	return value.replace(pattern, replacement)
}

/**
 * @param {string} value
 * @param {string} search
 * @return {number}
 */
function indexof (value, search) {
	return value.indexOf(search)
}

/**
 * @param {string} value
 * @param {number} index
 * @return {number}
 */
function charat (value, index) {
	return value.charCodeAt(index) | 0
}

/**
 * @param {string} value
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function substr (value, begin, end) {
	return value.slice(begin, end)
}

/**
 * @param {string} value
 * @return {number}
 */
function strlen (value) {
	return value.length
}

/**
 * @param {any[]} value
 * @return {number}
 */
function sizeof (value) {
	return value.length
}

/**
 * @param {any} value
 * @param {any[]} array
 * @return {any}
 */
function append (value, array) {
	return array.push(value), value
}

/**
 * @param {string[]} array
 * @param {function} callback
 * @return {string}
 */
function combine (array, callback) {
	return array.map(callback).join('')
}


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/colors.ts":
/*!*****************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/colors.ts ***!
  \*****************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   colors: function() { return /* binding */ colors; }
/* harmony export */ });
const colors = {
    primary: {
        50: "#FFF5F5",
        100: "#ffdbdb",
        200: "#ff9292",
        300: "#FF4949", // Primary
        400: "#FF3535",
        500: "#ff0000",
        600: "#b60000",
    },
    cyan: {
        50: "#F0FDFE", // Very light cyan
        100: "#DEFAFC", // Light cyan
        200: "#9BF1F6", // Light aqua
        300: "#58E8F0", // Aqua
        400: "#15DFEA", // Bright cyan
        500: "#14D4DE", // Cyan
        600: "#0FA0A7", // Teal
    },
    gray: {
        100: "#eff2f5",
        200: "#cfd8e2",
        300: "#afbecf",
        400: "#90a4bc",
        500: "#7089a9",
        600: "#56708f",
        700: "#43576f",
        800: "#2F3D4E",
        900: "#1d2530",
        1000: "#0a0c10",
    },
    success: "#10b981",
    warning: "#f59e0b",
    error: "#ef4444",
    info: "#FF4949",
    white: "#ffffff",
    transparent: "rgba(0, 0, 0, 0)",
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/admin-layout/component.tsx":
/*!*********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/admin-layout/component.tsx ***!
  \*********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AdminLayout: function() { return /* binding */ AdminLayout; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _card__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _flex__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _flex_item__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../flex-item */ "../../../../redfox-packages/core-components/src/components/flex-item/index.ts");
/* harmony import */ var _logo__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../logo */ "../../../../redfox-packages/core-components/src/components/logo/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/admin-layout/styled.tsx");








/**
 * AdminLayout component provides a flexible layout for admin interfaces
 * with a sticky sidebar and main content area.
 *
 * @example
 * ```tsx
 * <AdminLayout
 *   logo={<Logo />}
 *   appName="My Admin Panel"
 *   appVersion="v1.0.0"
 *   navigation={<Navigation />}
 * >
 *   <YourContent />
 * </AdminLayout>
 * ```
 */
const AdminLayout = ({ children, appName, appVersion, navigation, sidebarFooter, sidebarWidth = "300px", contentMaxWidth = "900px", gap = "30px", stickyTop = "40px", sidebarStyleProps, contentStyleProps, className, testId, }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_4__.Flex, { direction: "row", gap: gap, fullWidth: true, ...(className && { className }), "data-testid": testId, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { flex: `0 0 ${sidebarWidth}`, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_3__.Card, { styleProps: {
                        background: sidebarStyleProps?.background || _colors__WEBPACK_IMPORTED_MODULE_2__.colors.white,
                        radius: sidebarStyleProps?.radius || "10px",
                        boxShadow: sidebarStyleProps?.shadow,
                        stickyTop,
                    }, sticky: true, overflowHidden: true, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_4__.Flex, { direction: "column", gap: "0", fullWidth: true, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_3__.Card, { styleProps: { padding: "30px" }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_logo__WEBPACK_IMPORTED_MODULE_6__.Logo, {}) }) }), (appName || appVersion) && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_card__WEBPACK_IMPORTED_MODULE_3__.Card, { styleProps: {
                                        padding: "20px 30px",
                                        borderTop: `1px solid ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[100]}`,
                                    }, children: [appName && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.AppName, { children: appName }), appVersion && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_7__.AppVersion, { children: ["v", appVersion] })] }) })), navigation && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.NavigationSection, { children: navigation }) })), sidebarFooter && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_3__.Card, { styleProps: {
                                        padding: "20px 30px",
                                        borderTop: `1px solid ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[100]}`,
                                    }, children: sidebarFooter }) }))] }) }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_5__.FlexItem, { flex: "1", maxWidth: contentMaxWidth, children: contentStyleProps ? ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_3__.Card, { styleProps: contentStyleProps, children: children })) : (children) })] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/admin-layout/index.ts":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/admin-layout/index.ts ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AdminLayout: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.AdminLayout; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/admin-layout/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/admin-layout/styled.tsx":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/admin-layout/styled.tsx ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AppName: function() { return /* binding */ AppName; },
/* harmony export */   AppVersion: function() { return /* binding */ AppVersion; },
/* harmony export */   NavigationSection: function() { return /* binding */ NavigationSection; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");


const AppName = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  font-size: 1.1rem;
  font-weight: 500;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[700]};
  line-height: 1.4;
  margin-bottom: 4px;
`;
const AppVersion = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500]};
  line-height: 1.4;
  font-weight: 600;
`;
const NavigationSection = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].nav `
  flex: 1;
  overflow-y: auto;
  overflow-x: hidden;
  max-height: calc(100vh - 300px);

  &::-webkit-scrollbar {
    width: 6px;
  }

  &::-webkit-scrollbar-track {
    background: transparent;
  }

  &::-webkit-scrollbar-thumb {
    background: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[300]};
    border-radius: 3px;
  }

  &::-webkit-scrollbar-thumb:hover {
    background: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[400]};
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/badge/badge-styles.ts":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/badge/badge-styles.ts ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getBadgeSizeStyles: function() { return /* binding */ getBadgeSizeStyles; },
/* harmony export */   getBadgeVariantStyles: function() { return /* binding */ getBadgeVariantStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default colors
const DEFAULT_COLORS = {
    primary: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300],
    white: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white,
    gray100: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[100],
    gray300: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300],
    transparent: "transparent",
};
// Default size styles
const getBadgeSizeStyles = (size) => {
    switch (size) {
        case "small":
            return `
        padding: 2px 8px;
        font-size: 0.92em;
        line-height: 1.2;
      `;
        case "large":
            return `
        padding: 6px 12px;
        font-size: 1.2em;
        line-height: 1.6;
      `;
        case "medium":
        default:
            return `
        padding: 4px 10px;
        font-size: 1em;
        line-height: 1.4;
      `;
    }
};
// Default variant styles
const getBadgeVariantStyles = (variant, styleProps) => {
    const { backgroundColor, color, borderColor } = styleProps ?? {};
    switch (variant) {
        case "solid":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.primary};
        color: ${color ?? DEFAULT_COLORS.white};
        border: 1px solid ${borderColor ?? backgroundColor ?? DEFAULT_COLORS.primary};
      `;
        case "outline":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.transparent};
        color: ${color ?? DEFAULT_COLORS.primary};
        border: 1px solid ${borderColor ?? color ?? DEFAULT_COLORS.primary};
      `;
        case "ghost":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.gray100};
        color: ${color ?? DEFAULT_COLORS.primary};
        border: 1px solid ${borderColor ?? DEFAULT_COLORS.transparent};
      `;
        default:
            return "";
    }
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/badge/component.tsx":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/badge/component.tsx ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Badge: function() { return /* binding */ Badge; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/badge/styled.tsx");



const Badge = ({ children, size = "medium", variant = "solid", className, testId, styleProps, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledBadge, { "$size": size, "$variant": variant, "$styleProps": styleProps, ...(className && { className }), "data-testid": testId, ...props, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/badge/index.ts":
/*!*********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/badge/index.ts ***!
  \*********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Badge: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Badge; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/badge/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/badge/styled.tsx":
/*!***********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/badge/styled.tsx ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledBadge: function() { return /* binding */ StyledBadge; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _badge_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./badge-styles */ "../../../../redfox-packages/core-components/src/components/badge/badge-styles.ts");


const StyledBadge = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  display: inline-flex;
  align-items: center;
  justify-content: center;
  gap: 6px;
  font-weight: ${({ $styleProps }) => $styleProps?.fontWeight ?? 600};
  border-radius: ${({ $styleProps }) => $styleProps?.borderRadius ?? "9999px"};
  user-select: none;
  white-space: nowrap;
  font-size: ${({ $styleProps }) => $styleProps?.fontSize ?? "inherit"};
  padding: ${({ $styleProps }) => $styleProps?.padding ?? "0"};
  margin: ${({ $styleProps }) => $styleProps?.margin ?? "0"};

  ${({ $size = "medium", $styleProps }) => {
    // If custom padding is provided, don't use default size styles
    if ($styleProps?.padding)
        return "";
    return (0,_badge_styles__WEBPACK_IMPORTED_MODULE_1__.getBadgeSizeStyles)($size);
}}

  ${({ $variant = "solid", $styleProps }) => (0,_badge_styles__WEBPACK_IMPORTED_MODULE_1__.getBadgeVariantStyles)($variant, $styleProps)}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/button/button-styles.ts":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/button/button-styles.ts ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getButtonSizeStyles: function() { return /* binding */ getButtonSizeStyles; },
/* harmony export */   getButtonVariantStyles: function() { return /* binding */ getButtonVariantStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default colors
const DEFAULT_COLORS = {
    white: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white,
    gray100: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[100],
    gray300: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300],
    gray600: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[600],
    transparent: "transparent",
};
// Default size styles
const getButtonSizeStyles = (size) => {
    switch (size) {
        case "small":
            return `
        padding: 6px 12px;
        font-size: 1em;
        line-height: 20px;
      `;
        case "large":
            return `
        padding: 11px 26px;
        font-size: 1.35em;
        line-height: 28px;
      `;
        case "medium":
        default:
            return `
        padding: 9px 18px;
        font-size: 1.1em;
        line-height: 24px;
      `;
    }
};
// Default variant styles
const getButtonVariantStyles = (variant, styleProps) => {
    const { backgroundColor, hoverBackgroundColor, activeBackgroundColor, color, hoverColor, activeColor, borderColor, hoverBorderColor, activeBorderColor, } = styleProps ?? {};
    switch (variant) {
        case "solid":
            return `
        background-color: ${backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        color: ${color ?? DEFAULT_COLORS.white};
        border: 1px solid ${borderColor ?? backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        
        &:hover:not(:disabled) {
          background-color: ${hoverBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[500]};
          color: ${hoverColor ?? DEFAULT_COLORS.white};
          border-color: ${hoverBorderColor ?? hoverBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[500]};
        }
        
        &:active:not(:disabled) {
          background-color: ${activeBackgroundColor ?? "#4338ca"};
          color: ${activeColor ?? DEFAULT_COLORS.white};
          border-color: ${activeBorderColor ?? activeBackgroundColor ?? "#4338ca"};
        }
      `;
        case "outline":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.transparent};
        color: ${color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        border: 1px solid ${borderColor ?? color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        
        &:hover:not(:disabled) {
          background-color: ${hoverBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
          color: ${hoverColor ?? DEFAULT_COLORS.white};
          border-color: ${hoverBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        }
        
        &:active:not(:disabled) {
          background-color: ${activeBackgroundColor ?? "#4338ca"};
          color: ${activeColor ?? DEFAULT_COLORS.white};
          border-color: ${activeBorderColor ?? "#4338ca"};
        }
      `;
        case "ghost":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.transparent};
        color: ${color ?? DEFAULT_COLORS.gray600};
        border: 1px solid ${borderColor ?? DEFAULT_COLORS.transparent};
        
        &:hover:not(:disabled) {
          background-color: ${hoverBackgroundColor ?? DEFAULT_COLORS.gray100};
          color: ${hoverColor ?? DEFAULT_COLORS.gray600};
          border-color: ${hoverBorderColor ?? DEFAULT_COLORS.transparent};
        }
        
        &:active:not(:disabled) {
          background-color: ${activeBackgroundColor ?? DEFAULT_COLORS.gray300};
          color: ${activeColor ?? DEFAULT_COLORS.gray600};
          border-color: ${activeBorderColor ?? DEFAULT_COLORS.transparent};
        }
      `;
        case "link":
            return `
        background-color: ${backgroundColor ?? DEFAULT_COLORS.transparent};
        color: ${color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        border: 1px solid ${borderColor ?? DEFAULT_COLORS.transparent};
        text-decoration: underline;
        padding: 0;
        
        &:hover:not(:disabled) {
          background-color: ${hoverBackgroundColor ?? DEFAULT_COLORS.transparent};
          color: ${hoverColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[500]};
          border-color: ${hoverBorderColor ?? DEFAULT_COLORS.transparent};
          text-decoration: none;
        }
        
        &:active:not(:disabled) {
          background-color: ${activeBackgroundColor ?? DEFAULT_COLORS.transparent};
          color: ${activeColor ?? "#4338ca"};
          border-color: ${activeBorderColor ?? DEFAULT_COLORS.transparent};
          text-decoration: none;
        }
      `;
        default:
            return "";
    }
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/button/component.tsx":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/button/component.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Button: function() { return /* binding */ Button; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/button/styled.tsx");



const Button = ({ children, size = "medium", variant = "solid", disabled = false, loading = false, onClick, type = "button", className, testId, styleProps, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledButton, { "$size": size, "$variant": variant, "$styleProps": styleProps, disabled: disabled || loading, ...(onClick && { onClick }), type: type, ...(className && { className }), "data-testid": testId, ...props, children: [loading && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.LoadingSpinner, {}), children] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/button/index.ts":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/button/index.ts ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Button: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Button; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/button/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/button/styled.tsx":
/*!************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/button/styled.tsx ***!
  \************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   LoadingSpinner: function() { return /* binding */ LoadingSpinner; },
/* harmony export */   StyledButton: function() { return /* binding */ StyledButton; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _button_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./button-styles */ "../../../../redfox-packages/core-components/src/components/button/button-styles.ts");


const StyledButton = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  /* Base styles */
  display: inline-flex;
  align-items: center;
  justify-content: center;
  gap: 8px;
  border: none;
  outline: none;
  transition: all 0.2s ease-in-out;
  cursor: pointer;
  white-space: nowrap;
  text-decoration: none;
  font-weight: 500;
  border-radius: 5px;

  /* Apply default size styles if no custom sizing is provided */
  ${({ $size = "medium", $styleProps }) => !$styleProps?.padding && !$styleProps?.fontSize
    ? (0,_button_styles__WEBPACK_IMPORTED_MODULE_1__.getButtonSizeStyles)($size)
    : ""}

  /* Apply default variant styles if no custom colors are provided */
  ${({ $variant, $styleProps }) => (0,_button_styles__WEBPACK_IMPORTED_MODULE_1__.getButtonVariantStyles)($variant, $styleProps)}

  /* Apply width and height styles if provided */
  ${({ $styleProps }) => $styleProps?.width && `width: ${$styleProps.width};`}
  ${({ $styleProps }) => $styleProps?.height && `height: ${$styleProps.height};`}

  /* Apply box shadow styles if provided */
  ${({ $styleProps }) => $styleProps?.boxShadow && `box-shadow: ${$styleProps.boxShadow};`}

  /* Apply hover box shadow styles if provided */
  &:hover {
    ${({ $styleProps }) => $styleProps?.hoverBoxShadow &&
    `box-shadow: ${$styleProps.hoverBoxShadow};`}
  }

  /* Apply active box shadow styles if provided */
  &:active {
    ${({ $styleProps }) => $styleProps?.activeBoxShadow &&
    `box-shadow: ${$styleProps.activeBoxShadow};`}
  }

  /* Disabled state */
  &:disabled {
    opacity: 0.5;
    cursor: not-allowed;
  }
`;
const LoadingSpinner = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  width: 16px;
  height: 16px;
  border: 2px solid transparent;
  border-top: 2px solid currentColor;
  border-radius: 50%;
  animation: spin 1s linear infinite;

  @keyframes spin {
    0% {
      transform: rotate(0deg);
    }
    100% {
      transform: rotate(360deg);
    }
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/card/card-styles.ts":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/card/card-styles.ts ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getCardBaseStyles: function() { return /* binding */ getCardBaseStyles; },
/* harmony export */   getCardCenterStyles: function() { return /* binding */ getCardCenterStyles; },
/* harmony export */   getCardClickableStyles: function() { return /* binding */ getCardClickableStyles; },
/* harmony export */   getCardStickyStyles: function() { return /* binding */ getCardStickyStyles; }
/* harmony export */ });
// Default shadows
const DEFAULT_SHADOWS = {
    sm: "0 1px 2px 0 rgb(0 0 0 / 0.05)",
    md: "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)",
};
// Get base card styles
const getCardBaseStyles = (styleProps) => {
    if (!styleProps)
        return "";
    const { padding, radius, background, height, boxShadow, border, borderTop, borderBottom, borderLeft, borderRight, } = styleProps;
    return `
    ${padding ? `padding: ${padding};` : ""}
    ${radius ? `border-radius: ${radius};` : ""}
    ${background ? `background: ${background};` : ""}
    ${height ? `height: ${height};` : ""}
    ${boxShadow ? `box-shadow: ${boxShadow};` : ""}
    ${(() => {
        if (border === undefined)
            return "";
        return border ? `border: ${border};` : "border: none;";
    })()}
    ${borderTop ? `border-top: ${borderTop};` : ""}
    ${borderBottom ? `border-bottom: ${borderBottom};` : ""}
    ${borderLeft ? `border-left: ${borderLeft};` : ""}
    ${borderRight ? `border-right: ${borderRight};` : ""}
  `;
};
// Get clickable styles
const getCardClickableStyles = (clickable, styleProps) => {
    if (!clickable)
        return "";
    const { hoverBackgroundColor, hoverBorderColor, hoverBoxShadow, activeBoxShadow, } = styleProps ?? {};
    return `
    cursor: pointer;
    
    &:hover {
      transform: translateY(-1px);
      background-color: ${hoverBackgroundColor ?? "inherit"};
      border-color: ${hoverBorderColor ?? "inherit"};
      box-shadow: ${hoverBoxShadow ?? DEFAULT_SHADOWS.sm};
    }
    
    &:active {
      transform: translateY(0);
      box-shadow: ${activeBoxShadow ?? DEFAULT_SHADOWS.md};
    }
  `;
};
// Get center styles
const getCardCenterStyles = (center) => {
    if (!center)
        return "";
    return `
    display: flex;
    align-items: center;
    justify-content: center;
    text-align: center;
  `;
};
// Get sticky styles
const getCardStickyStyles = (sticky, styleProps) => {
    if (!sticky)
        return "";
    const { stickyTop = "0" } = styleProps ?? {};
    return `
    position: sticky;
    top: ${stickyTop};
    z-index: 10;
  `;
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/card/component.tsx":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/card/component.tsx ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Card: function() { return /* binding */ Card; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/card/styled.tsx");



const Card = ({ children, clickable = false, overflowHidden = false, center = false, sticky = false, className, testId, styleProps, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledCard, { "$clickable": clickable, "$overflowHidden": overflowHidden, "$center": center, "$sticky": sticky, "$styleProps": styleProps, className: className, "data-testid": testId, ...props, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/card/index.ts":
/*!********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/card/index.ts ***!
  \********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Card: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Card; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/card/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/card/styled.tsx":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/card/styled.tsx ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledCard: function() { return /* binding */ StyledCard; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _card_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./card-styles */ "../../../../redfox-packages/core-components/src/components/card/card-styles.ts");


const StyledCard = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: relative;
  display: block;
  transition:
    box-shadow 0.2s ease,
    transform 0.1s ease,
    background-color 0.2s ease,
    border-color 0.2s ease;

  /* Apply base styles from styleProps */
  ${({ $styleProps }) => (0,_card_styles__WEBPACK_IMPORTED_MODULE_1__.getCardBaseStyles)($styleProps)}

  /* Apply clickable styles */
  ${({ $clickable = false, $styleProps }) => (0,_card_styles__WEBPACK_IMPORTED_MODULE_1__.getCardClickableStyles)($clickable, $styleProps)}

  /* Apply overflow hidden */
  ${({ $overflowHidden }) => $overflowHidden && `overflow: hidden;`}

  /* Apply center styles */
  ${({ $center = false }) => (0,_card_styles__WEBPACK_IMPORTED_MODULE_1__.getCardCenterStyles)($center)}

  /* Apply sticky styles */
  ${({ $sticky = false, $styleProps }) => (0,_card_styles__WEBPACK_IMPORTED_MODULE_1__.getCardStickyStyles)($sticky, $styleProps)}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex-item/component.tsx":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex-item/component.tsx ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   FlexItem: function() { return /* binding */ FlexItem; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/flex-item/styled.tsx");



const FlexItem = ({ children, flex, grow, shrink, basis, order, maxWidth, alignSelf, className, testId, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledFlexItem, { ...(flex !== undefined && { $flex: flex }), ...(grow !== undefined && { $grow: grow }), ...(shrink !== undefined && { $shrink: shrink }), ...(basis !== undefined && { $basis: basis }), ...(order !== undefined && { $order: order }), ...(maxWidth !== undefined && { $maxWidth: maxWidth }), ...(alignSelf !== undefined && { $alignSelf: alignSelf }), className: className, "data-testid": testId, ...props, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex-item/index.ts":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex-item/index.ts ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   FlexItem: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.FlexItem; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/flex-item/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex-item/styled.tsx":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex-item/styled.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledFlexItem: function() { return /* binding */ StyledFlexItem; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");


const StyledFlexItem = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  ${({ $flex }) => $flex != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      flex: ${$flex};
    `}

  ${({ $grow }) => $grow != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      flex-grow: ${$grow};
    `}

  ${({ $shrink }) => $shrink != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      flex-shrink: ${$shrink};
    `}

  ${({ $basis }) => $basis != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      flex-basis: ${typeof $basis === "number" ? `${$basis}px` : $basis};
    `}

  ${({ $order }) => $order != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      order: ${$order};
    `}

  ${({ $alignSelf }) => $alignSelf != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      align-self: ${$alignSelf};
    `}

  ${({ $maxWidth }) => $maxWidth != null &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      max-width: ${$maxWidth};
    `}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex/component.tsx":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex/component.tsx ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Flex: function() { return /* binding */ Flex; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/flex/styled.tsx");



const Flex = ({ children, direction = "row", wrap = "nowrap", justify = "flex-start", align = "stretch", gap, inline = false, fullWidth = false, fullHeight = false, maxWidth, className, testId, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledFlex, { "$direction": direction, "$wrap": wrap, "$justify": justify, "$align": align, ...(gap !== undefined && { $gap: gap }), "$inline": inline, "$fullWidth": fullWidth, "$fullHeight": fullHeight, ...(maxWidth !== undefined && { $maxWidth: maxWidth }), className: className, "data-testid": testId, ...props, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex/index.ts":
/*!********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex/index.ts ***!
  \********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Flex: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Flex; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/flex/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/flex/styled.tsx":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/flex/styled.tsx ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledFlex: function() { return /* binding */ StyledFlex; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");


const gapMap = {
    none: "0",
    xs: "4px",
    sm: "8px",
    md: "16px",
    lg: "24px",
    xl: "32px",
};
const getGapValue = (gap) => {
    const safeGap = gap ?? "none";
    // If it's a predefined gap value, use the mapped value
    if (safeGap in gapMap) {
        return gapMap[safeGap] ?? safeGap;
    }
    // Otherwise, return the gap value as-is (assuming it's a valid CSS unit)
    return safeGap;
};
const StyledFlex = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: ${({ $inline }) => ($inline ? "inline-flex" : "flex")};
  flex-direction: ${({ $direction = "row" }) => $direction};
  flex-wrap: ${({ $wrap = "nowrap" }) => $wrap};
  justify-content: ${({ $justify = "flex-start" }) => $justify};
  align-items: ${({ $align = "stretch" }) => $align};
  gap: ${({ $gap = "none" }) => getGapValue($gap)};
  width: ${({ $fullWidth }) => ($fullWidth ? "100%" : "auto")};
  height: ${({ $fullHeight }) => ($fullHeight ? "100%" : "auto")};
  ${({ $maxWidth }) => $maxWidth && `max-width: ${$maxWidth};`}

  ${({ $gap }) => $gap === "none" &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      gap: 0;
    `}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/input/component.tsx":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/input/component.tsx ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Input: function() { return /* binding */ Input; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/input/styled.tsx");



const Input = ({ variant = "outline", size = "medium", startIcon, endIcon, error = false, className, testId, styleProps, ...props }) => {
    const hasStartIcon = Boolean(startIcon);
    const hasEndIcon = Boolean(endIcon);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_2__.Container, { className: className, "$fullWidth": props.style?.width === "100%", "$styleProps": styleProps, children: [hasStartIcon && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.IconWrapper, { position: "start", "$styleProps": styleProps, children: startIcon })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.StyledInput, { "$variant": variant, "$size": size, "$hasStartIcon": hasStartIcon, "$hasEndIcon": hasEndIcon, "$error": error, "$styleProps": styleProps, "data-testid": testId, ...props }), hasEndIcon && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.IconWrapper, { position: "end", "$styleProps": styleProps, children: endIcon }))] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/input/index.ts":
/*!*********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/input/index.ts ***!
  \*********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Input: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Input; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/input/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/input/input-styles.ts":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/input/input-styles.ts ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getInputSizeStyles: function() { return /* binding */ getInputSizeStyles; },
/* harmony export */   getInputVariantStyles: function() { return /* binding */ getInputVariantStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default size styles
const getInputSizeStyles = (size) => {
    switch (size) {
        case "small":
            return `
        padding: 10px 12px !important;
        font-size: 0.9em;
        line-height: 20px;
      `;
        case "large":
            return `
        padding: 15px 20px !important;
        font-size: 1.2em;
        line-height: 28px;
      `;
        case "medium":
        default:
            return `
        padding: 10px 14px !important;
        font-size: 1em;
        line-height: 24px;
      `;
    }
};
// Default variant styles
const getInputVariantStyles = (variant, error, styleProps) => {
    const { backgroundColor, focusBackgroundColor, errorBackgroundColor, borderColor, focusBorderColor, errorBorderColor, color, placeholderColor, } = styleProps ?? {};
    const getErrorStyles = () => {
        if (!error)
            return "";
        return `
      border-color: ${errorBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.error} !important;
      background-color: ${errorBackgroundColor ?? backgroundColor ?? "inherit"};
    `;
    };
    switch (variant) {
        case "outline":
            return `
        background-color: ${backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
        border-color: ${borderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300]} !important;
        color: ${color ?? "inherit"};

        &:focus {
          border-color: ${focusBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]} !important;
          background-color: ${focusBackgroundColor ?? backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
        }

        &::placeholder {
          color: ${placeholderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[400]};
        }

        ${getErrorStyles()}
      `;
        case "filled":
            return `
        background-color: ${backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[100]};
        border-color: ${borderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.transparent} !important;
        color: ${color ?? "inherit"};

        &:focus {
          border-color: ${focusBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
          background-color: ${focusBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
        }

        &::placeholder {
          color: ${placeholderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[400]};
        }

        ${getErrorStyles()}
      `;
        default:
            return "";
    }
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/input/styled.tsx":
/*!***********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/input/styled.tsx ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Container: function() { return /* binding */ Container; },
/* harmony export */   IconWrapper: function() { return /* binding */ IconWrapper; },
/* harmony export */   StyledInput: function() { return /* binding */ StyledInput; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _input_styles__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./input-styles */ "../../../../redfox-packages/core-components/src/components/input/input-styles.ts");




const Container = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].label `
  display: inline-flex;
  align-items: center;
  position: relative;
  width: ${({ $fullWidth }) => ($fullWidth ? "100%" : "auto")};
  margin: ${({ $styleProps }) => $styleProps?.margin ?? "0"};
`;
const IconWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].span `
  display: inline-flex;
  align-items: center;
  justify-content: center;
  position: absolute;
  top: 0;
  bottom: 0;
  color: ${({ $styleProps }) => $styleProps?.iconColor ?? _colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[500]};
  ${({ position }) => position === "start"
    ? (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
          left: 8px;
        `
    : (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
          right: 8px;
        `}
`;
const StyledInput = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].input `
  width: 100%;
  border-radius: ${({ $styleProps }) => $styleProps?.borderRadius ?? "5px"} !important;
  transition: all 0.2s ease-in-out;
  outline: none;
  border: 1px solid transparent !important;
  color: ${({ $styleProps }) => $styleProps?.color ?? _colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[800]} !important;
  font-size: ${({ $styleProps }) => $styleProps?.fontSize ?? "inherit"};
  padding: ${({ $styleProps }) => $styleProps?.padding ?? "inherit"};
  margin: ${({ $styleProps }) => $styleProps?.margin ?? "0"};
  box-shadow: none !important;
  outline: none !important;

  ${({ $size = "medium", $styleProps }) => {
    // If custom padding is provided, don't use default size styles
    if ($styleProps?.padding)
        return "";
    return (0,_input_styles__WEBPACK_IMPORTED_MODULE_3__.getInputSizeStyles)($size);
}}

  ${({ $hasStartIcon }) => $hasStartIcon &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      padding-left: 32px !important;
    `}

  ${({ $hasEndIcon }) => $hasEndIcon &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      padding-right: 32px !important;
    `}

  ${({ $variant = "outline", $error = false, $styleProps }) => (0,_input_styles__WEBPACK_IMPORTED_MODULE_3__.getInputVariantStyles)($variant, $error, $styleProps)}

  &:disabled {
    background-color: ${({ $styleProps }) => $styleProps?.backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[100]};
    cursor: not-allowed;
  }

  &[readonly] {
    background-color: ${({ $styleProps }) => $styleProps?.backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_2__.colors.white} !important;
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/loading-spinner/component.tsx":
/*!************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/loading-spinner/component.tsx ***!
  \************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   LoadingSpinner: function() { return /* binding */ LoadingSpinner; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/loading-spinner/styled.tsx");



/**
 * A creative and customizable loading spinner component with multiple animation variants
 *
 * @example
 * ```tsx
 * // Basic usage
 * <LoadingSpinner isLoading={true} />
 *
 * // With custom variant and size
 * <LoadingSpinner
 *   isLoading={true}
 *   variant="pulse"
 *   size="large"
 *   color="primary"
 * />
 *
 * // With loading text
 * <LoadingSpinner
 *   isLoading={true}
 *   variant="ring"
 *   showText={true}
 *   text="Loading data..."
 * />
 *
 * // Full screen overlay (fixed position)
 * <LoadingSpinner
 *   isLoading={true}
 *   variant="fold"
 *   overlay={true}
 *   overlayMode="fixed"
 *   centered={true}
 * />
 *
 * // Content overlay (absolute position)
 * <LoadingSpinner
 *   isLoading={true}
 *   variant="ring"
 *   overlay={true}
 *   overlayMode="absolute"
 *   centered={true}
 *   overlayColor="rgba(255, 255, 255, 0.9)"
 * />
 * ```
 */
const LoadingSpinner = ({ isLoading = true, variant = "rotate", size = "medium", color = "primary", speed = "normal", width, height, showText = false, text = "Loading...", centered = false, overlay = false, overlayMode = "fixed", overlayColor = "rgba(255, 255, 255, 0.5)", disabled = false, ariaLabel, className, style, children, ...props }) => {
    // Don't render spinner if not loading and no children
    if (!isLoading && !children) {
        return null;
    }
    // Show children when not loading
    if (!isLoading && children) {
        return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: children });
    }
    const spinnerProps = {
        testId: props.testId,
        size,
        color,
        speed,
        width,
        height,
        disabled,
    };
    const renderSpinner = () => {
        switch (variant) {
            case "pulse":
                return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.PulseSpinner, { ...spinnerProps });
            case "bounce":
                return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.BounceSpinner, { ...spinnerProps });
            case "ring":
                return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.RingSpinner, { ...spinnerProps });
            case "fold":
                return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.FoldSpinner, { ...spinnerProps });
            case "rotate":
            default:
                return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.RotateSpinner, { ...spinnerProps });
        }
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_2__.SpinnerWrapper, { className: className, style: style, centered: centered, overlay: overlay, overlayMode: overlayMode, overlayColor: overlayColor, disabled: disabled, role: "status", "aria-label": ariaLabel ?? (showText ? text : "Loading"), "aria-live": "polite", ...props, children: [renderSpinner(), showText && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.LoadingText, { size: size, color: color, children: text }))] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/loading-spinner/index.ts":
/*!*******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/loading-spinner/index.ts ***!
  \*******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   LoadingSpinner: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.LoadingSpinner; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/loading-spinner/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/loading-spinner/styled.tsx":
/*!*********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/loading-spinner/styled.tsx ***!
  \*********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   BounceSpinner: function() { return /* binding */ BounceSpinner; },
/* harmony export */   FoldSpinner: function() { return /* binding */ FoldSpinner; },
/* harmony export */   LoadingText: function() { return /* binding */ LoadingText; },
/* harmony export */   PulseSpinner: function() { return /* binding */ PulseSpinner; },
/* harmony export */   RingSpinner: function() { return /* binding */ RingSpinner; },
/* harmony export */   RotateSpinner: function() { return /* binding */ RotateSpinner; },
/* harmony export */   SpinnerElement: function() { return /* binding */ SpinnerElement; },
/* harmony export */   SpinnerWrapper: function() { return /* binding */ SpinnerWrapper; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");



// Keyframe animations for different spinner variants
const pulseAnimation = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  0%, 100% { opacity: 1; transform: scale(1); }
  50% { opacity: 0.5; transform: scale(1.1); }
`;
const rotateAnimation = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
`;
const bounceAnimation = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  0%, 20%, 53%, 80%, 100% { transform: translate3d(0, 0, 0); }
  40%, 43% { transform: translate3d(0, -30px, 0); }
  70% { transform: translate3d(0, -15px, 0); }
  90% { transform: translate3d(0, -4px, 0); }
`;
const ringAnimation = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  0% { transform: rotate(0deg); }
  100% { transform: rotate(360deg); }
`;
const foldAnimation = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  0%, 10%, 20%, 80%, 90%, 100% { transform: rotateX(0deg); }
  40%, 60% { transform: rotateX(-180deg); }
`;
// Size configurations
const sizeMap = {
    small: { width: "16px", height: "16px", fontSize: "0.9em" },
    medium: { width: "24px", height: "24px", fontSize: "1em" },
    large: { width: "32px", height: "32px", fontSize: "1.1em" },
    xlarge: { width: "48px", height: "48px", fontSize: "1.2em" },
};
// Speed configurations
const speedMap = {
    slow: "2s",
    normal: "1.2s",
    fast: "0.8s",
};
// Color configurations
const colorMap = {
    primary: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.primary[300],
    secondary: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[500], // closest match
    success: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.success,
    warning: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.warning,
    error: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.error,
    info: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.info,
    white: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.white,
    black: _colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[1000],
};
// Main wrapper styled component
const SpinnerWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: ${({ centered }) => (centered ? "flex" : "inline-flex")};
  align-items: center;
  justify-content: center;
  flex-direction: column;
  gap: 8px;

  ${({ overlay, overlayColor, overlayMode = "fixed" }) => overlay &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      position: ${overlayMode};
      top: 0;
      left: 0;
      right: 0;
      bottom: 0;
      background-color: ${overlayColor};
      z-index: ${overlayMode === "fixed" ? "9999" : "999"};
      backdrop-filter: blur(5px);
    `}

  ${({ disabled }) => disabled &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.5;
      pointer-events: none;
    `}
`;
// Base spinner element
const SpinnerElement = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  position: relative;
  display: inline-block;

  ${({ size = "medium", width, height }) => {
    const sizeConfig = sizeMap[size];
    return (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      width: ${width ?? sizeConfig.width};
      height: ${height ?? sizeConfig.height};
    `;
}}

  ${({ color = "primary" }) => (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
    color: ${colorMap[color]};
  `}
  
  ${({ speed = "normal" }) => (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
    --spinner-speed: ${speedMap[speed]};
  `}
`;
// Pulse variant
const PulseSpinner = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"])(SpinnerElement) `
  background-color: currentColor;
  border-radius: 50%;
  animation: ${pulseAnimation} var(--spinner-speed) ease-in-out infinite;
`;
// Rotate variant
const RotateSpinner = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"])(SpinnerElement) `
  border: 2px solid rgba(0, 0, 0, 0.1);
  border-top: 2px solid currentColor;
  border-radius: 50%;
  animation: ${rotateAnimation} var(--spinner-speed) linear infinite;
`;
// Bounce variant
const BounceSpinner = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"])(SpinnerElement) `
  background-color: currentColor;
  border-radius: 50%;
  animation: ${bounceAnimation} var(--spinner-speed) ease-in-out infinite;
`;
// Ring variant
const RingSpinner = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"])(SpinnerElement) `
  border: 3px solid rgba(0, 0, 0, 0.1);
  border-top: 3px solid currentColor;
  border-bottom: 3px solid currentColor;
  border-radius: 50%;
  animation: ${ringAnimation} var(--spinner-speed) linear infinite;
`;
// Fold variant
const FoldSpinner = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"])(SpinnerElement) `
  background-color: currentColor;
  transform-style: preserve-3d;
  animation: ${foldAnimation} var(--spinner-speed) ease-in-out infinite;
`;
// Loading text
const LoadingText = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].span `
  ${({ size = "medium" }) => {
    const sizeConfig = sizeMap[size];
    return (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      font-size: ${sizeConfig.fontSize};
    `;
}}

  ${({ color = "primary" }) => (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
    color: ${colorMap[color]};
  `}
  
  font-weight: 500;
  margin-top: 4px;
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/logo/component.tsx":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/logo/component.tsx ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Logo: function() { return /* binding */ Logo; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);


const Logo = (props) => {
    const width = props?.width ?? 168;
    const height = props?.height ?? 32;
    const accentColor = props?.accentColor ?? "#FF4949";
    const textColor = props?.textColor ?? "#2F3D4E";
    const className = props?.className ?? undefined;
    const testId = props?.testId ?? undefined;
    const title = props?.title ?? undefined;
    const ariaHidden = props?.ariaHidden ?? (title ? undefined : true);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)("svg", { width: width, height: height, viewBox: "0 0 168 32", fill: "none", xmlns: "http://www.w3.org/2000/svg", role: "img", "aria-hidden": ariaHidden, className: className, "data-testid": testId, children: [title ? (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("title", { children: title }) : null, (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { fillRule: "evenodd", clipRule: "evenodd", d: "M0.446249 0.0883647C0.720092 -0.0499623 1.04909 -0.0243875 1.29782 0.154562L9.77257 6.25178H17.6489L26.7229 0.140115C26.9734 -0.0285644 27.2974 -0.0462482 27.565 0.0941575C27.8326 0.234563 28 0.510057 28 0.81013V14.5836C28 14.7554 27.9449 14.9228 27.8426 15.0615L15.5982 31.6678C15.4442 31.8766 15.199 32 14.9381 32H12.4694C12.2018 32 11.951 31.8701 11.7982 31.6524L0.146307 15.0461C0.0510543 14.9103 0 14.7489 0 14.5836V0.81013C0 0.505541 0.172405 0.226692 0.446249 0.0883647ZM16.9774 7.87204H10.4301L11.4485 16.1667H15.959L16.9774 7.87204ZM17.4254 17.6389L25.2287 15.8602L17.0445 26.9599L16.3382 26.494L17.4254 17.6389ZM14.7417 26.0816H12.6658L11.6474 17.787H15.7601L14.7417 26.0816ZM9.56471 14.2388L8.88204 8.67862L2.5422 14.1664L8.02118 15.49L9.56471 14.2388ZM9.98121 17.6312L2.72095 15.8773L10.476 26.9297L11.0714 26.5107L9.98121 17.6312ZM13.1935 30.3797H14.214L14.5428 27.7019H12.8648L13.1935 30.3797ZM1.63504 12.8003V2.39942L8.19686 7.12038L1.63504 12.8003ZM26.365 12.8746V2.3403L19.2658 7.12183L26.365 12.8746ZM18.5326 8.62069L17.8449 14.222L19.5254 15.4977L25.3739 14.1645L18.5326 8.62069Z", fill: accentColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M154.891 24.256V7.45599H161.131C162.315 7.45599 163.363 7.69599 164.275 8.17599C165.187 8.63999 165.899 9.29599 166.411 10.144C166.923 10.976 167.179 11.944 167.179 13.048C167.179 14.136 166.931 15.104 166.435 15.952C165.939 16.8 165.259 17.472 164.395 17.968C163.531 18.448 162.531 18.688 161.395 18.688H158.179V24.256H154.891ZM158.179 15.664H161.323C162.059 15.664 162.659 15.424 163.123 14.944C163.603 14.448 163.843 13.816 163.843 13.048C163.843 12.28 163.579 11.656 163.051 11.176C162.539 10.696 161.875 10.456 161.059 10.456H158.179V15.664Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M144.706 24.256L149.53 7.45599H152.866L147.85 24.256H144.706ZM134.578 24.256L129.61 7.45599H132.946L137.722 24.256H134.578ZM135.01 24.256L139.594 7.45599H142.57L138.01 24.256H135.01ZM144.394 24.256L139.882 7.45599H142.858L147.538 24.256H144.394Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M111.072 24.256L115.992 17.392L119.424 12.256H123.168L118.392 18.952L114.864 24.256H111.072ZM119.688 24.256L116.208 18.952L111.384 12.256H115.128L118.56 17.392L123.456 24.256H119.688Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M104.317 24.544C103.101 24.544 102.013 24.28 101.053 23.752C100.109 23.208 99.3648 22.464 98.8208 21.52C98.2928 20.576 98.0288 19.488 98.0288 18.256C98.0288 17.024 98.2928 15.936 98.8208 14.992C99.3488 14.048 100.085 13.312 101.029 12.784C101.973 12.24 103.053 11.968 104.269 11.968C105.501 11.968 106.589 12.24 107.533 12.784C108.477 13.312 109.213 14.048 109.741 14.992C110.269 15.936 110.533 17.024 110.533 18.256C110.533 19.488 110.269 20.576 109.741 21.52C109.213 22.464 108.477 23.208 107.533 23.752C106.605 24.28 105.533 24.544 104.317 24.544ZM104.317 21.616C104.909 21.616 105.429 21.472 105.877 21.184C106.325 20.896 106.669 20.504 106.909 20.008C107.165 19.496 107.293 18.912 107.293 18.256C107.293 17.6 107.165 17.024 106.909 16.528C106.653 16.016 106.293 15.616 105.829 15.328C105.381 15.04 104.861 14.896 104.269 14.896C103.693 14.896 103.173 15.04 102.709 15.328C102.261 15.616 101.909 16.016 101.653 16.528C101.397 17.024 101.269 17.6 101.269 18.256C101.269 18.912 101.397 19.496 101.653 20.008C101.909 20.504 102.269 20.896 102.733 21.184C103.197 21.472 103.725 21.616 104.317 21.616Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M86.0312 24.256V7.45599H96.8073V10.456H89.3192V14.488H95.5592V17.488H89.3192V24.256H86.0312Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M79.8458 24.256L79.6778 22.024V7.45599H82.8458V24.256H79.8458ZM76.0778 24.544C74.9738 24.544 74.0138 24.288 73.1978 23.776C72.3978 23.264 71.7738 22.536 71.3258 21.592C70.8778 20.648 70.6538 19.536 70.6538 18.256C70.6538 16.96 70.8778 15.848 71.3258 14.92C71.7738 13.976 72.3978 13.248 73.1978 12.736C74.0138 12.224 74.9738 11.968 76.0778 11.968C77.0858 11.968 77.9338 12.224 78.6218 12.736C79.3258 13.248 79.8618 13.976 80.2298 14.92C80.5978 15.848 80.7818 16.96 80.7818 18.256C80.7818 19.536 80.5978 20.648 80.2298 21.592C79.8618 22.536 79.3258 23.264 78.6218 23.776C77.9338 24.288 77.0858 24.544 76.0778 24.544ZM76.8938 21.64C77.4378 21.64 77.9178 21.496 78.3338 21.208C78.7658 20.92 79.1018 20.52 79.3418 20.008C79.5818 19.496 79.7018 18.912 79.7018 18.256C79.7018 17.6 79.5818 17.016 79.3418 16.504C79.1018 15.992 78.7658 15.6 78.3338 15.328C77.9178 15.04 77.4298 14.896 76.8698 14.896C76.2938 14.896 75.7898 15.04 75.3578 15.328C74.9258 15.6 74.5818 15.992 74.3258 16.504C74.0698 17.016 73.9418 17.6 73.9418 18.256C73.9418 18.912 74.0698 19.496 74.3258 20.008C74.5818 20.52 74.9258 20.92 75.3578 21.208C75.8058 21.496 76.3178 21.64 76.8938 21.64Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M63.4367 24.544C62.2527 24.544 61.2047 24.28 60.2927 23.752C59.3807 23.208 58.6607 22.464 58.1327 21.52C57.6207 20.576 57.3647 19.488 57.3647 18.256C57.3647 17.024 57.6287 15.936 58.1567 14.992C58.7007 14.048 59.4367 13.312 60.3647 12.784C61.3087 12.24 62.3887 11.968 63.6047 11.968C64.6607 11.968 65.6287 12.248 66.5087 12.808C67.4047 13.352 68.1167 14.16 68.6447 15.232C69.1887 16.288 69.4607 17.576 69.4607 19.096H60.3647L60.6527 18.808C60.6527 19.4 60.7967 19.92 61.0847 20.368C61.3887 20.8 61.7727 21.136 62.2367 21.376C62.7167 21.6 63.2287 21.712 63.7727 21.712C64.4287 21.712 64.9647 21.576 65.3807 21.304C65.7967 21.016 66.1167 20.648 66.3407 20.2L69.1727 21.304C68.8367 21.976 68.3967 22.56 67.8527 23.056C67.3247 23.536 66.6927 23.904 65.9567 24.16C65.2207 24.416 64.3807 24.544 63.4367 24.544ZM60.8207 17.032L60.5327 16.744H66.3167L66.0527 17.032C66.0527 16.456 65.9167 16 65.6447 15.664C65.3727 15.312 65.0367 15.056 64.6367 14.896C64.2527 14.736 63.8767 14.656 63.5087 14.656C63.1407 14.656 62.7487 14.736 62.3327 14.896C61.9167 15.056 61.5567 15.312 61.2527 15.664C60.9647 16 60.8207 16.456 60.8207 17.032Z", fill: textColor }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("path", { d: "M43 24.256V7.45599H49.24C50.424 7.45599 51.472 7.68799 52.384 8.15199C53.296 8.61599 54.008 9.25599 54.52 10.072C55.032 10.872 55.288 11.808 55.288 12.88C55.288 13.936 55.016 14.88 54.472 15.712C53.944 16.528 53.216 17.168 52.288 17.632C51.36 18.08 50.304 18.304 49.12 18.304H46.288V24.256H43ZM52.24 24.256L48.352 17.512L50.872 15.712L55.96 24.256H52.24ZM46.288 15.304H49.264C49.76 15.304 50.2 15.2 50.584 14.992C50.984 14.784 51.296 14.496 51.52 14.128C51.76 13.76 51.88 13.344 51.88 12.88C51.88 12.16 51.616 11.576 51.088 11.128C50.576 10.68 49.912 10.456 49.096 10.456H46.288V15.304Z", fill: textColor })] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/logo/index.ts":
/*!********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/logo/index.ts ***!
  \********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Logo: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Logo; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/logo/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/modal/component.tsx":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/modal/component.tsx ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Modal: function() { return /* binding */ Modal; },
/* harmony export */   ModalBody: function() { return /* binding */ ModalBody; },
/* harmony export */   ModalFooter: function() { return /* binding */ ModalFooter; },
/* harmony export */   ModalHeader: function() { return /* binding */ ModalHeader; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/XMarkIcon.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _button__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/modal/styled.tsx");





const Modal = ({ isOpen, onClose, children, title, footer, className = "", testId, styleProps, showCloseButton = true, closeOnBackdropClick = true, closeOnEscape = true, preventBodyScroll = true, strings, }) => {
    // Handle body scroll prevention
    (0,react__WEBPACK_IMPORTED_MODULE_2__.useEffect)(() => {
        if (!isOpen || !preventBodyScroll)
            return;
        const originalOverflow = document.body.style.overflow;
        document.body.style.overflow = "hidden";
        return () => {
            document.body.style.overflow = originalOverflow;
        };
    }, [isOpen, preventBodyScroll]);
    // Handle escape key
    (0,react__WEBPACK_IMPORTED_MODULE_2__.useEffect)(() => {
        if (!isOpen || !closeOnEscape)
            return;
        const handleEscape = (event) => {
            if (event.key === "Escape") {
                onClose();
            }
        };
        document.addEventListener("keydown", handleEscape);
        return () => document.removeEventListener("keydown", handleEscape);
    }, [isOpen, closeOnEscape, onClose]);
    const handleBackdropClick = (event) => {
        if (closeOnBackdropClick && event.target === event.currentTarget) {
            onClose();
        }
    };
    if (!isOpen)
        return null;
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_4__.StyledModalBackdrop, { "$styleProps": styleProps, onClick: handleBackdropClick, "data-testid": testId ? `${testId}-backdrop` : undefined, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_4__.StyledModal, { "$styleProps": styleProps, className: className, onClick: (e) => e.stopPropagation(), "data-testid": testId, role: "dialog", "aria-modal": "true", "aria-labelledby": title ? "modal-title" : undefined, children: [(title ?? showCloseButton) && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(ModalHeader, { title: title, onClose: onClose, showCloseButton: showCloseButton, strings: strings })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(ModalBody, { children: children }), footer && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(ModalFooter, { children: footer })] }) }));
};
const ModalHeader = ({ title, onClose, showCloseButton = true, className = "", children, strings, }) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_4__.StyledModalHeader, { className: className, children: children ?? ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [title && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("h3", { id: "modal-title", children: title }), showCloseButton && onClose && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_3__.Button, { onClick: onClose, variant: "link", size: "small", "aria-label": strings?.closeModal, type: "button", styleProps: {
                    color: "#90A4BC",
                }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { height: 20, width: 20 }) }))] })) }));
const ModalBody = ({ children, className = "", }) => (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_4__.StyledModalBody, { className: className, children: children });
const ModalFooter = ({ children, className = "", align = "right", }) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_4__.StyledModalFooter, { "$align": align, className: className, children: children }));


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/modal/index.ts":
/*!*********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/modal/index.ts ***!
  \*********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Modal: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Modal; },
/* harmony export */   ModalBody: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.ModalBody; },
/* harmony export */   ModalFooter: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.ModalFooter; },
/* harmony export */   ModalHeader: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.ModalHeader; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/modal/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/modal/styled.tsx":
/*!***********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/modal/styled.tsx ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledCloseButton: function() { return /* binding */ StyledCloseButton; },
/* harmony export */   StyledModal: function() { return /* binding */ StyledModal; },
/* harmony export */   StyledModalBackdrop: function() { return /* binding */ StyledModalBackdrop; },
/* harmony export */   StyledModalBody: function() { return /* binding */ StyledModalBody; },
/* harmony export */   StyledModalFooter: function() { return /* binding */ StyledModalFooter; },
/* harmony export */   StyledModalHeader: function() { return /* binding */ StyledModalHeader; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");


const StyledModalBackdrop = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: fixed;
  top: 0;
  left: 0;
  right: 0;
  bottom: 0;
  background-color: ${({ $styleProps }) => $styleProps?.backdropColor ?? `${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]}80`}; /* 50% opacity */
  backdrop-filter: blur(5px);
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: ${({ $styleProps }) => $styleProps?.zIndex ?? 9999999};
  padding: 20px;
  box-sizing: border-box;

  /* Smooth fade-in animation */
  animation: fadeIn 0.2s ease-out;

  @keyframes fadeIn {
    from {
      opacity: 0;
    }
    to {
      opacity: 1;
    }
  }
`;
const StyledModal = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  background-color: ${({ $styleProps }) => $styleProps?.backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.white};
  border-radius: ${({ $styleProps }) => $styleProps?.borderRadius ?? "10px"};
  max-width: ${({ $styleProps }) => $styleProps?.maxWidth ?? "600px"};
  min-width: ${({ $styleProps }) => $styleProps?.minWidth ?? "320px"};
  width: ${({ $styleProps }) => $styleProps?.width ?? "100%"};
  max-height: ${({ $styleProps }) => $styleProps?.maxHeight ?? "90vh"};
  min-height: ${({ $styleProps }) => $styleProps?.minHeight ?? "auto"};
  height: ${({ $styleProps }) => $styleProps?.height ?? "auto"};
  margin: ${({ $styleProps }) => $styleProps?.margin ?? "auto"};
  border: ${({ $styleProps }) => $styleProps?.border ?? "none"};
  display: flex;
  flex-direction: column;
  overflow: ${({ $styleProps }) => $styleProps?.overflow ?? "hidden"};
  position: relative;

  /* Smooth scale-in animation */
  animation: scaleIn 0.2s ease-out;

  @keyframes scaleIn {
    from {
      transform: scale(0.95);
      opacity: 0;
    }
    to {
      transform: scale(1);
      opacity: 1;
    }
  }

  /* Mobile responsiveness */
  @media (max-width: 768px) {
    margin: 20px;
    max-width: calc(100vw - 40px);
    max-height: calc(100vh - 40px);
  }
`;
const StyledModalHeader = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  padding: 20px 30px;
  border-bottom: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[100]};
  display: flex;
  align-items: center;
  justify-content: space-between;
  flex-shrink: 0;

  h2,
  h3,
  h4 {
    margin: 0;
    font-size: 1.2em;
    font-weight: 500;
    color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
    line-height: 1.2;
  }
`;
const StyledModalBody = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  padding: 20px 24px;
  flex: 1;
  overflow-y: auto;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
  line-height: 1.6;

  /* Custom scrollbar for better aesthetics */
  &::-webkit-scrollbar {
    width: 6px;
  }

  &::-webkit-scrollbar-track {
    background: #f3f4f6;
    border-radius: 3px;
  }

  &::-webkit-scrollbar-thumb {
    background: #d1d5db;
    border-radius: 3px;
  }

  &::-webkit-scrollbar-thumb:hover {
    background: #9ca3af;
  }
`;
const StyledModalFooter = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  padding: 20px 30px;
  border-top: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[100]};
  display: flex;
  align-items: center;
  flex-shrink: 0;
  gap: 12px;

  justify-content: ${({ $align }) => {
    switch ($align) {
        case "left":
            return "flex-start";
        case "center":
            return "center";
        case "right":
            return "flex-end";
        case "space-between":
            return "space-between";
        default:
            return "flex-end";
    }
}};

  /* Mobile responsiveness */
  @media (max-width: 480px) {
    flex-direction: column-reverse;
    align-items: stretch;

    button {
      width: 100%;
    }
  }
`;
const StyledCloseButton = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  background: none;
  border: none;
  padding: 8px;
  cursor: pointer;
  border-radius: 4px;
  color: #6b7280;
  transition: all 0.2s ease;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 32px;
  height: 32px;

  &:hover {
    background-color: #f3f4f6;
    color: #374151;
  }

  &:focus {
    outline: 2px solid #3b82f6;
    outline-offset: 2px;
  }

  svg {
    width: 20px;
    height: 20px;
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notification-message/component.tsx":
/*!*****************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notification-message/component.tsx ***!
  \*****************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationMessage: function() { return /* binding */ NotificationMessage; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/solid */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/CheckCircleIcon.js");
/* harmony import */ var _heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/solid */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/ExclamationTriangleIcon.js");
/* harmony import */ var _heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/solid */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/InformationCircleIcon.js");
/* harmony import */ var _heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @heroicons/react/24/solid */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XCircleIcon.js");
/* harmony import */ var _heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @heroicons/react/24/solid */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/solid/esm/XMarkIcon.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/notification-message/styled.tsx");




// Default icons for each variant using Heroicons
const DefaultIcons = {
    success: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_1__["default"], {}),
    error: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_4__["default"], {}),
    warning: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_2__["default"], {}),
    info: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_3__["default"], {}),
};
// Close/dismiss icon using Heroicons
const CloseIcon = (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_solid__WEBPACK_IMPORTED_MODULE_5__["default"], {});
const NotificationMessage = ({ children, variant = "info", size = "medium", title, showIcon = true, icon, dismissible = false, onDismiss, visible = true, autoHide = false, autoHideDelay = 5000, className, testId, styleProps, ...props }) => {
    const [isVisible, setIsVisible] = (0,react__WEBPACK_IMPORTED_MODULE_6__.useState)(visible);
    const [isDismissing, setIsDismissing] = (0,react__WEBPACK_IMPORTED_MODULE_6__.useState)(false);
    // Handle dismiss with animation
    const handleDismiss = (0,react__WEBPACK_IMPORTED_MODULE_6__.useCallback)(() => {
        if (!isVisible)
            return;
        setIsDismissing(true);
        // Wait for animation to complete before hiding
        setTimeout(() => {
            setIsVisible(false);
            setIsDismissing(false);
            onDismiss?.();
        }, 200); // Match the transition duration in styled component
    }, [isVisible, onDismiss]);
    // Handle visibility changes from props
    (0,react__WEBPACK_IMPORTED_MODULE_6__.useEffect)(() => {
        setIsVisible(visible);
    }, [visible]);
    // Handle auto-hide functionality
    (0,react__WEBPACK_IMPORTED_MODULE_6__.useEffect)(() => {
        if (autoHide && isVisible && autoHideDelay > 0) {
            const timer = setTimeout(() => {
                handleDismiss();
            }, autoHideDelay);
            return () => clearTimeout(timer);
        }
        return () => { };
    }, [autoHide, isVisible, autoHideDelay, handleDismiss]);
    // Handle keyboard events for dismiss button
    const handleKeyDown = (0,react__WEBPACK_IMPORTED_MODULE_6__.useCallback)((event) => {
        if (event.key === "Enter" || event.key === " ") {
            event.preventDefault();
            handleDismiss();
        }
    }, [handleDismiss]);
    // Don't render if not visible and not dismissing
    if (!isVisible && !isDismissing) {
        return null;
    }
    const iconToShow = icon ?? (showIcon ? DefaultIcons[variant] : null);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationContainer, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationMessage, { "$variant": variant, "$size": size, "$visible": isVisible && !isDismissing, "$styleProps": styleProps, className: `${className ?? ""} ${isDismissing ? "notification-dismissing" : ""}`.trim(), "data-testid": testId, role: "alert", "aria-live": "polite", ...props, children: [iconToShow && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationIcon, { "$variant": variant, "$size": size, "$styleProps": styleProps, className: "notification-icon", children: iconToShow })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationContent, { children: [title && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationTitle, { className: "notification-title", children: title })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledNotificationText, { className: "notification-message", children: children })] }), dismissible && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_7__.StyledDismissButton, { "$variant": variant, "$size": size, className: "notification-dismiss", onClick: handleDismiss, onKeyDown: handleKeyDown, "aria-label": "Dismiss notification", type: "button", children: CloseIcon }))] }) }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notification-message/index.ts":
/*!************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notification-message/index.ts ***!
  \************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationMessage: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.NotificationMessage; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/notification-message/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notification-message/notification-styles.ts":
/*!**************************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notification-message/notification-styles.ts ***!
  \**************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getNotificationDismissButtonStyles: function() { return /* binding */ getNotificationDismissButtonStyles; },
/* harmony export */   getNotificationIconSizeStyles: function() { return /* binding */ getNotificationIconSizeStyles; },
/* harmony export */   getNotificationMessageSizeStyles: function() { return /* binding */ getNotificationMessageSizeStyles; },
/* harmony export */   getNotificationMessageVariantStyles: function() { return /* binding */ getNotificationMessageVariantStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default colors for notification variants
const DEFAULT_COLORS = {
    success: {
        background: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.cyan[50], // Light background for success
        color: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.cyan[600], // Dark text for contrast
        icon: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.cyan[600],
    },
    error: {
        background: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[50], // Light red background
        color: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[600], // Dark text for contrast
        icon: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.error,
    },
    warning: {
        background: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[100], // Light background for warning
        color: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[800], // Dark text for contrast
        icon: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.warning,
    },
    info: {
        background: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[50], // Light primary background
        color: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300], // Darker primary for better contrast
        icon: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.info,
    },
};
// Default size styles
const getNotificationMessageSizeStyles = (size) => {
    switch (size) {
        case "small":
            return `
        padding: 12px;
        font-size: 0.9em;
        line-height: 20px;
        gap: 8px;
        
        .notification-title {
          font-size: 0.9em;
          margin-bottom: 4px;
        }
        
        .notification-icon {
          width: 16px;
          height: 16px;
          flex-shrink: 0;
        }
        
        .notification-dismiss {
          width: 16px;
          height: 16px;
          padding: 2px;
        }
      `;
        case "large":
            return `
        padding: 20px;
        font-size: 1.2em;
        line-height: 24px;
        gap: 14px;
        
        .notification-title {
          font-size: 1.2em;
          margin-bottom: 8px;
        }
        
        .notification-icon {
          width: 24px;
          height: 24px;
          flex-shrink: 0;
        }
        
        .notification-dismiss {
          width: 20px;
          height: 20px;
          padding: 4px;
        }
      `;
        case "medium":
        default:
            return `
        padding: 16px;
        font-size: 1em;
        line-height: 22px;
        gap: 12px;
        
        .notification-title {
          font-size: 1em;
          margin-bottom: 6px;
        }
        
        .notification-icon {
          width: 20px;
          height: 20px;
          flex-shrink: 0;
        }
        
        .notification-dismiss {
          width: 18px;
          height: 18px;
          padding: 3px;
        }
      `;
    }
};
// Default variant styles
const getNotificationMessageVariantStyles = (variant, styleProps) => {
    const variantColors = DEFAULT_COLORS[variant];
    const { backgroundColor, color, borderColor, iconColor, boxShadow } = styleProps ?? {};
    return `
    background-color: ${backgroundColor ?? variantColors.background};
    ${borderColor ? `border: 1px solid ${borderColor};` : ""};
    color: ${color ?? variantColors.color};
     ${boxShadow ? `box-shadow:${boxShadow};` : ""};
    
    .notification-icon {
      color: ${iconColor ?? variantColors.icon};
    }
    
    .notification-dismiss {
      color: ${color ?? variantColors.color};
      opacity: 0.5;
      
      &:hover {
        opacity: 1;
        transform: scale(1.1);
      }
    }
  `;
};
// Icon size styles
const getNotificationIconSizeStyles = (size, styleProps) => {
    const sizeStyles = getNotificationMessageSizeStyles(size);
    // Extract icon size from the size styles
    const iconSizeMatch = sizeStyles.match(/\.notification-icon\s*{\s*width:\s*([^;]+);/);
    const iconSize = iconSizeMatch?.[1]?.trim() ?? "20px";
    return `
    width: ${iconSize};
    height: ${iconSize};
    flex-shrink: 0;
    color: ${styleProps?.iconColor ?? "inherit"};
  `;
};
// Dismiss button styles
const getNotificationDismissButtonStyles = (size, variant) => {
    const variantColors = DEFAULT_COLORS[variant];
    const sizeStyles = getNotificationMessageSizeStyles(size);
    // Extract dismiss button size from the size styles
    const dismissSizeMatch = sizeStyles.match(/\.notification-dismiss\s*{\s*width:\s*([^;]+);.*?height:\s*([^;]+);.*?padding:\s*([^;]+);/s);
    const dismissWidth = dismissSizeMatch?.[1]?.trim() ?? "18px";
    const dismissHeight = dismissSizeMatch?.[2]?.trim() ?? "18px";
    const dismissPadding = dismissSizeMatch?.[3]?.trim() ?? "3px";
    return `
    width: ${dismissWidth};
    height: ${dismissHeight};
    padding: ${dismissPadding};
    margin-left: auto;
    background: transparent;
    border: none;
    border-radius: 4px;
    cursor: pointer;
    color: ${variantColors.color};
    opacity: 0.7;
    display: flex;
    align-items: center;
    justify-content: center;
    transition: all 0.15s ease-in-out;
    flex-shrink: 0;
    
    &:hover {
      opacity: 1;
    }
    
    &:active {
      background-color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300]};
    }
    
    &:focus {
      outline: none;
    }
    
    svg {
      width: 100%;
      height: 100%;
    }
  `;
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notification-message/styled.tsx":
/*!**************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notification-message/styled.tsx ***!
  \**************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledDismissButton: function() { return /* binding */ StyledDismissButton; },
/* harmony export */   StyledNotificationContainer: function() { return /* binding */ StyledNotificationContainer; },
/* harmony export */   StyledNotificationContent: function() { return /* binding */ StyledNotificationContent; },
/* harmony export */   StyledNotificationIcon: function() { return /* binding */ StyledNotificationIcon; },
/* harmony export */   StyledNotificationMessage: function() { return /* binding */ StyledNotificationMessage; },
/* harmony export */   StyledNotificationText: function() { return /* binding */ StyledNotificationText; },
/* harmony export */   StyledNotificationTitle: function() { return /* binding */ StyledNotificationTitle; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _notification_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./notification-styles */ "../../../../redfox-packages/core-components/src/components/notification-message/notification-styles.ts");


const StyledNotificationMessage = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: ${({ $visible }) => ($visible ? "flex" : "none")};
  align-items: flex-start;
  border-radius: ${({ $styleProps }) => $styleProps?.borderRadius ?? "8px"};
  font-weight: ${({ $styleProps }) => $styleProps?.fontWeight ?? 400};
  font-size: ${({ $styleProps }) => $styleProps?.fontSize ?? "inherit"};
  padding: ${({ $styleProps }) => $styleProps?.padding ?? "0"};
  margin: ${({ $styleProps }) => $styleProps?.margin ?? "0"};
  position: relative;
  transition: all 0.2s ease-in-out;

  ${({ $size = "medium", $styleProps }) => {
    // If custom padding is provided, don't use default size styles
    if ($styleProps?.padding)
        return "";
    return (0,_notification_styles__WEBPACK_IMPORTED_MODULE_1__.getNotificationMessageSizeStyles)($size);
}}

  ${({ $variant = "info", $styleProps }) => (0,_notification_styles__WEBPACK_IMPORTED_MODULE_1__.getNotificationMessageVariantStyles)($variant, $styleProps)}

  /* Animation for showing/hiding */
  opacity: ${({ $visible }) => ($visible ? 1 : 0)};
  transform: ${({ $visible }) => $visible ? "translateY(0)" : "translateY(-8px)"};

  /* Fade out animation when dismissing */
  &.notification-dismissing {
    opacity: 0;
    transform: translateY(-8px);
  }
`;
const StyledNotificationIcon = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  align-items: center;
  justify-content: center;
  flex-shrink: 0;

  ${({ $size = "medium", $styleProps }) => (0,_notification_styles__WEBPACK_IMPORTED_MODULE_1__.getNotificationIconSizeStyles)($size, $styleProps)}
`;
const StyledNotificationContent = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  flex: 1;
  min-width: 0; /* Prevents flex item from overflowing */
`;
const StyledNotificationTitle = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  font-weight: 600;
  margin-bottom: 4px;

  &:last-child {
    margin-bottom: 0;
  }
`;
const StyledNotificationText = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  line-height: 1.5;
`;
const StyledDismissButton = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  ${({ $size = "medium", $variant = "info" }) => (0,_notification_styles__WEBPACK_IMPORTED_MODULE_1__.getNotificationDismissButtonStyles)($size, $variant)}
`;
const StyledNotificationContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: relative;
  width: 100%;
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notifications-container/component.tsx":
/*!********************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notifications-container/component.tsx ***!
  \********************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationsContainer: function() { return /* binding */ NotificationsContainer; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _notification_message__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../notification-message */ "../../../../redfox-packages/core-components/src/components/notification-message/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/notifications-container/styled.tsx");

/**
 * Notifications Container Component
 *
 * Displays success and error notifications for settings operations using core NotificationMessage component.
 *
 * @since 1.0.0
 */



/**
 * Notifications Container Component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const NotificationsContainer = ({ notifications, onDismiss, }) => {
    const [notificationStates, setNotificationStates] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)([]);
    const activeTimersRef = (0,react__WEBPACK_IMPORTED_MODULE_1__.useRef)(new Map());
    // Update notification states when notifications prop changes
    (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
        setNotificationStates((prevStates) => {
            const newStates = [];
            // Handle existing notifications
            notifications.forEach((notification) => {
                const existingState = prevStates.find((state) => state.id === notification.id);
                if (existingState) {
                    // Keep existing state but update data
                    newStates.push({
                        ...notification,
                        isVisible: existingState.isVisible,
                        isExiting: existingState.isExiting,
                    });
                }
                else {
                    // New notification - start hidden, will animate in
                    newStates.push({
                        ...notification,
                        isVisible: false,
                        isExiting: false,
                    });
                }
            });
            // Keep exiting notifications until animation completes
            prevStates.forEach((prevState) => {
                if (prevState.isExiting &&
                    !notifications.find((n) => n.id === prevState.id)) {
                    newStates.push(prevState);
                }
            });
            return newStates;
        });
    }, [notifications]);
    // Animate new notifications in
    (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
        const newNotifications = notificationStates.filter((state) => !state.isVisible && !state.isExiting);
        if (newNotifications.length > 0) {
            // Small delay to ensure DOM is updated before animation
            const timer = setTimeout(() => {
                setNotificationStates((prevStates) => prevStates.map((state) => newNotifications.find((n) => n.id === state.id)
                    ? { ...state, isVisible: true }
                    : state));
            }, 50);
            return () => clearTimeout(timer);
        }
        return () => { };
    }, [notificationStates]);
    // Handle dismiss with animation
    const handleDismiss = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((id) => {
        // Clear any active timer for this notification
        const timer = activeTimersRef.current.get(id);
        if (timer) {
            clearTimeout(timer);
            activeTimersRef.current.delete(id);
        }
        setNotificationStates((prevStates) => prevStates.map((state) => state.id === id ? { ...state, isExiting: true } : state));
        // Remove after animation completes
        setTimeout(() => {
            setNotificationStates((prevStates) => prevStates.filter((state) => state.id !== id));
            onDismiss(id);
        }, 300);
    }, [onDismiss]);
    // Auto-dismiss notifications
    (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
        notificationStates.forEach((notification) => {
            // Only set timer if notification is visible, not exiting, and doesn't already have a timer
            if (notification.isVisible &&
                !notification.isExiting &&
                !activeTimersRef.current.has(notification.id)) {
                const delay = notification.variant === "success" ? 5000 : 8000;
                const timer = setTimeout(() => {
                    handleDismiss(notification.id);
                    activeTimersRef.current.delete(notification.id);
                }, delay);
                activeTimersRef.current.set(notification.id, timer);
            }
        });
        // Clean up timers for notifications that no longer exist
        const currentIds = new Set(notificationStates.map((n) => n.id));
        activeTimersRef.current.forEach((timer, id) => {
            if (!currentIds.has(id)) {
                clearTimeout(timer);
                activeTimersRef.current.delete(id);
            }
        });
    }, [notificationStates, handleDismiss]);
    // Clean up all timers on unmount
    (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
        const timersMap = activeTimersRef.current;
        return () => {
            timersMap.forEach((timer) => clearTimeout(timer));
            timersMap.clear();
        };
    }, []);
    if (notificationStates.length === 0) {
        return null;
    }
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_3__.NotificationsWrapper, { children: notificationStates.map((notification) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_3__.NotificationAnimationWrapper, { "$isVisible": notification.isVisible, "$isExiting": notification.isExiting, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_notification_message__WEBPACK_IMPORTED_MODULE_2__.NotificationMessage, { variant: notification.variant, dismissible: true, onDismiss: () => handleDismiss(notification.id), visible: true, autoHide: false, autoHideDelay: 0, children: notification.message }) }, notification.id))) }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notifications-container/index.ts":
/*!***************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notifications-container/index.ts ***!
  \***************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationsContainer: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.NotificationsContainer; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/notifications-container/component.tsx");
/**
 * Notifications Container Component Exports
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/notifications-container/styled.tsx":
/*!*****************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/notifications-container/styled.tsx ***!
  \*****************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationAnimationWrapper: function() { return /* binding */ NotificationAnimationWrapper; },
/* harmony export */   NotificationsWrapper: function() { return /* binding */ NotificationsWrapper; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/**
 * Notifications Container Styled Components
 *
 * @since 1.0.0
 */

/**
 * Notifications container styled component.
 *
 * @since 1.0.0
 */
const NotificationsWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: fixed;
  bottom: 20px;
  right: 20px;
  z-index: 9999;
  display: flex;
  flex-direction: column-reverse;
  width: 350px;
  max-width: calc(100vw - 40px);
  pointer-events: none;

  > * {
    pointer-events: auto;
  }
`;
/**
 * Animation wrapper for individual notifications.
 *
 * @since 1.0.0
 */
const NotificationAnimationWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  transform: translateX(
    ${({ $isVisible, $isExiting }) => $isVisible && !$isExiting ? "0" : "100%"}
  );
  opacity: ${({ $isVisible, $isExiting }) => $isVisible && !$isExiting ? "1" : "0"};
  transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
  margin-bottom: 12px;

  /* Initial state for new notifications */
  ${({ $isVisible }) => !$isVisible &&
    `
    transform: translateX(100%);
    opacity: 0;
  `}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/pagination/component.tsx":
/*!*******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/pagination/component.tsx ***!
  \*******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Pagination: function() { return /* binding */ Pagination; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleLeftIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDoubleRightIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronLeftIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronRightIcon.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/pagination/styled.tsx");

/**
 * Pagination Component
 *
 * A reusable pagination component with page navigation and items per page selector.
 *
 * @since 1.0.0
 */



/**
 * Pagination component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const Pagination = (props) => {
    const { currentPage, totalPages, totalItems, itemsPerPage, onPageChange, onItemsPerPageChange, showItemsPerPageSelector = true, itemsPerPageOptions = [10, 25, 50, 100], maxPageButtons = 7, disabled = false, className = "", showPageInfo = true, showFirstLastButtons = true, strings, } = props;
    /**
     * Calculate page numbers to display
     *
     * @since 1.0.0
     *
     * @return Array of page numbers and ellipsis indicators.
     */
    const pageNumbers = (0,react__WEBPACK_IMPORTED_MODULE_5__.useMemo)(() => {
        const pages = [];
        if (totalPages <= maxPageButtons) {
            // Show all pages
            for (let i = 1; i <= totalPages; i++) {
                pages.push(i);
            }
        }
        else {
            // Calculate range around current page
            const sidePages = Math.floor((maxPageButtons - 3) / 2); // Reserve space for first, last, and ellipsis
            const startPage = Math.max(2, currentPage - sidePages);
            const endPage = Math.min(totalPages - 1, currentPage + sidePages);
            // Always show first page
            pages.push(1);
            // Add ellipsis if needed
            if (startPage > 2) {
                pages.push("ellipsis");
            }
            // Add pages around current page
            for (let i = startPage; i <= endPage; i++) {
                pages.push(i);
            }
            // Add ellipsis if needed
            if (endPage < totalPages - 1) {
                pages.push("ellipsis");
            }
            // Always show last page (if not already included)
            if (totalPages > 1) {
                pages.push(totalPages);
            }
        }
        return pages;
    }, [currentPage, totalPages, maxPageButtons]);
    /**
     * Calculate the current range of items being shown
     *
     * @since 1.0.0
     */
    const itemRange = (0,react__WEBPACK_IMPORTED_MODULE_5__.useMemo)(() => {
        if (totalItems === 0)
            return { startItem: 0, endItem: 0 };
        const startItem = (currentPage - 1) * itemsPerPage + 1;
        const endItem = Math.min(currentPage * itemsPerPage, totalItems);
        return { startItem, endItem };
    }, [currentPage, itemsPerPage, totalItems]);
    /**
     * Handle page change
     *
     * @since 1.0.0
     *
     * @param page Page number to navigate to.
     */
    const handlePageChange = (page) => {
        if (disabled || page < 1 || page > totalPages || page === currentPage) {
            return;
        }
        onPageChange(page);
    };
    /**
     * Handle items per page change
     *
     * @since 1.0.0
     *
     * @param event Select change event.
     */
    const handleItemsPerPageChange = (event) => {
        const newItemsPerPage = parseInt(event.target.value, 10);
        onItemsPerPageChange?.(newItemsPerPage);
    };
    // Don't render if there's only one page and no items per page selector
    if (totalPages <= 1 && !showItemsPerPageSelector) {
        return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, {});
    }
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.PaginationContainer, { className: `redfox-pagination ${className}`.trim(), children: [showPageInfo && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageInfo, { children: (() => {
                    if (totalItems === 0)
                        return strings.noItems;
                    if (totalItems === 1)
                        return strings.oneItem;
                    return `${strings.showing} ${itemRange.startItem}-${itemRange.endItem} ${strings.of} ${totalItems} ${strings.items}`;
                })() })), totalPages > 1 && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.NavigationContainer, { children: [showFirstLastButtons && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageButton, { onClick: () => handlePageChange(1), disabled: disabled || currentPage === 1, title: strings.firstPage, "aria-label": strings.goToFirstPage, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 16, height: 16 }) })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageButton, { onClick: () => handlePageChange(currentPage - 1), disabled: disabled || currentPage === 1, title: strings.previousPage, "aria-label": strings.goToPreviousPage, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { width: 16, height: 16 }) }), pageNumbers.map((page, index) => {
                        if (page === "ellipsis") {
                            return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.Ellipsis, { children: "\u2026" }, `ellipsis-${index}`);
                        }
                        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageButton, { onClick: () => handlePageChange(page), disabled: disabled, "$isActive": page === currentPage, title: `${strings.page} ${page}`, "aria-label": `${strings.goToPage} ${page}`, "aria-current": page === currentPage ? "page" : undefined, children: page }, page));
                    }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageButton, { onClick: () => handlePageChange(currentPage + 1), disabled: disabled || currentPage === totalPages, title: strings.nextPage, "aria-label": strings.goToNextPage, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_4__["default"], { width: 16, height: 16 }) }), showFirstLastButtons && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.PageButton, { onClick: () => handlePageChange(totalPages), disabled: disabled || currentPage === totalPages, title: strings.lastPage, "aria-label": strings.goToLastPage, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 16, height: 16 }) }))] })), showItemsPerPageSelector && onItemsPerPageChange && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.ItemsPerPageContainer, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("label", { htmlFor: "items-per-page", children: strings.itemsPerPage }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.ItemsPerPageSelect, { id: "items-per-page", value: itemsPerPage, onChange: handleItemsPerPageChange, disabled: disabled, children: itemsPerPageOptions.map((option) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("option", { value: option, children: option }, option))) })] }))] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/pagination/index.ts":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/pagination/index.ts ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Pagination: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Pagination; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/pagination/component.tsx");
/**
 * Pagination Component
 *
 * Export pagination component and types.
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/pagination/styled.tsx":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/pagination/styled.tsx ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Ellipsis: function() { return /* binding */ Ellipsis; },
/* harmony export */   ItemsPerPageContainer: function() { return /* binding */ ItemsPerPageContainer; },
/* harmony export */   ItemsPerPageSelect: function() { return /* binding */ ItemsPerPageSelect; },
/* harmony export */   NavigationContainer: function() { return /* binding */ NavigationContainer; },
/* harmony export */   PageButton: function() { return /* binding */ PageButton; },
/* harmony export */   PageInfo: function() { return /* binding */ PageInfo; },
/* harmony export */   PaginationContainer: function() { return /* binding */ PaginationContainer; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/**
 * Pagination Component Styled Elements
 *
 * Styled components for the pagination component.
 *
 * @since 1.0.0
 */


/**
 * Pagination container
 *
 * @since 1.0.0
 */
const PaginationContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 16px;
  padding: 16px 0;

  @media (max-width: 768px) {
    flex-direction: column;
    gap: 12px;
  }
`;
/**
 * Page info text
 *
 * @since 1.0.0
 */
const PageInfo = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
  font-size: 1em;
  white-space: nowrap;

  @media (max-width: 768px) {
    order: 3;
  }
`;
/**
 * Navigation container
 *
 * @since 1.0.0
 */
const NavigationContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  align-items: center;
  gap: 8px;
`;
/**
 * Page button
 *
 * @since 1.0.0
 */
const PageButton = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  min-width: 32px;
  height: 32px;
  padding: 4px 8px;
  border: 1px solid
    ${({ $isActive }) => ($isActive ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300] : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[100])};
  background: ${({ $isActive }) => $isActive ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300] : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.white};
  color: ${({ $isActive }) => ($isActive ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.white : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800])};
  font-size: 1em;
  border-radius: 3px;
  cursor: ${({ $disabled }) => ($disabled ? "not-allowed" : "pointer")};
  display: flex;
  align-items: center;
  justify-content: center;
  transition: all 0.2s ease;

  &:hover:not(:disabled) {
    background: ${({ $isActive }) => $isActive ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300] : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[50]};
    color: ${({ $isActive }) => $isActive ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.white : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
    border-color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
  }

  &:disabled {
    opacity: 0.5;
    cursor: not-allowed;
  }

  &:focus {
    outline: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
    outline-offset: -1px;
    box-shadow: none !important;
  }
`;
/**
 * Ellipsis indicator
 *
 * @since 1.0.0
 */
const Ellipsis = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  padding: 4px 8px;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500]};
  font-size: 1em;
`;
/**
 * Items per page container
 *
 * @since 1.0.0
 */
const ItemsPerPageContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  align-items: center;
  gap: 8px;
  font-size: 1em;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};

  @media (max-width: 768px) {
    order: 1;
  }
`;
/**
 * Items per page select
 *
 * @since 1.0.0
 */
const ItemsPerPageSelect = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].select `
  padding: 4px 8px;
  border: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[200]};
  border-radius: 3px;
  background: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.white};
  font-size: 1em;
  cursor: pointer;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};

  &:focus {
    outline: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
    outline-offset: -1px;
    box-shadow: none !important;
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/popover/component.tsx":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/popover/component.tsx ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Popover: function() { return /* binding */ Popover; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react-dom */ "react-dom");
/* harmony import */ var react_dom__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react_dom__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/popover/styled.tsx");




const Popover = ({ trigger, children, open, defaultOpen, onOpenChange, placement = "bottom-start", disabled: _disabled = false, className, testId, contentBackground, contentBorderColor, contentBorderRadius, contentPadding, contentMinWidth, contentMaxWidth, contentBoxShadow, contentZIndex, contentClassName, contentStyle, matchTriggerWidth = false, }) => {
    const isControlled = typeof open === "boolean";
    const [internalOpen, setInternalOpen] = react__WEBPACK_IMPORTED_MODULE_1___default().useState(Boolean(defaultOpen));
    const actualOpen = isControlled ? open : internalOpen;
    const [triggerWidth, setTriggerWidth] = react__WEBPACK_IMPORTED_MODULE_1___default().useState(undefined);
    const [triggerRect, setTriggerRect] = react__WEBPACK_IMPORTED_MODULE_1___default().useState(null);
    const wrapperRef = react__WEBPACK_IMPORTED_MODULE_1___default().useRef(null);
    const triggerRef = react__WEBPACK_IMPORTED_MODULE_1___default().useRef(null);
    // Use portal for high z-index values to escape modal containers
    const usePortal = (contentZIndex ?? 1000) > 5000;
    const setOpen = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((next) => {
        if (!isControlled)
            setInternalOpen(next);
        onOpenChange?.(next);
    }, [isControlled, onOpenChange]);
    // Calculate trigger width and position when opening
    react__WEBPACK_IMPORTED_MODULE_1___default().useLayoutEffect(() => {
        if (actualOpen && triggerRef.current) {
            const rect = triggerRef.current.getBoundingClientRect();
            if (matchTriggerWidth) {
                setTriggerWidth(rect.width);
            }
            if (usePortal) {
                setTriggerRect(rect);
            }
        }
    }, [matchTriggerWidth, actualOpen, usePortal]);
    const handleKeyDown = (e) => {
        if (e.key === "Escape") {
            setOpen(false);
        }
    };
    react__WEBPACK_IMPORTED_MODULE_1___default().useEffect(() => {
        const onKeyDown = (e) => {
            if (e.key === "Escape")
                setOpen(false);
        };
        if (actualOpen) {
            document.addEventListener("keydown", onKeyDown);
        }
        return () => document.removeEventListener("keydown", onKeyDown);
    }, [actualOpen, setOpen]);
    // Calculate portal position
    const getPortalStyle = () => {
        if (!usePortal || !triggerRect)
            return {};
        const style = {
            position: "fixed",
            zIndex: contentZIndex ?? 1000,
        };
        switch (placement) {
            case "bottom-start":
                style.top = triggerRect.bottom + 4;
                style.left = triggerRect.left;
                break;
            case "bottom-end":
                style.top = triggerRect.bottom + 4;
                style.right = window.innerWidth - triggerRect.right;
                break;
            case "top-start":
                style.bottom = window.innerHeight - triggerRect.top + 4;
                style.left = triggerRect.left;
                break;
            case "top-end":
                style.bottom = window.innerHeight - triggerRect.top + 4;
                style.right = window.innerWidth - triggerRect.right;
                break;
            default:
                style.top = triggerRect.bottom + 4;
                style.left = triggerRect.left;
        }
        if (matchTriggerWidth) {
            style.width = triggerRect.width;
        }
        return style;
    };
    const renderPopoverContent = () => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", { onClick: () => setOpen(false), onKeyDown: (e) => {
                    if (e.key === "Enter" || e.key === " ") {
                        e.preventDefault();
                        setOpen(false);
                    }
                }, role: "button", tabIndex: 0, "aria-label": "Close popover", style: {
                    position: "fixed",
                    inset: 0,
                    zIndex: (contentZIndex ?? 1000) - 1,
                } }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_3__.PopoverContent, { "$placement": usePortal ? "bottom-start" : placement, "$contentBackground": contentBackground, "$contentBorderColor": contentBorderColor, "$contentBorderRadius": contentBorderRadius, "$contentPadding": contentPadding, "$contentMinWidth": contentMinWidth, "$contentMaxWidth": contentMaxWidth, "$contentBoxShadow": contentBoxShadow, "$contentZIndex": contentZIndex, "$matchTriggerWidth": matchTriggerWidth, "$triggerWidth": triggerWidth, className: contentClassName, style: usePortal ? { ...getPortalStyle(), ...contentStyle } : contentStyle, children: children })] }));
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_3__.PopoverContainer, { ref: wrapperRef, className: className, "data-testid": testId, onKeyDown: handleKeyDown, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", { ref: triggerRef, role: "button", "aria-haspopup": "dialog", "aria-expanded": actualOpen, children: trigger }), actualOpen &&
                (() => {
                    if (usePortal && typeof document !== "undefined") {
                        return triggerRect
                            ? (0,react_dom__WEBPACK_IMPORTED_MODULE_2__.createPortal)(renderPopoverContent(), document.body)
                            : null;
                    }
                    return renderPopoverContent();
                })()] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/popover/index.ts":
/*!***********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/popover/index.ts ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Popover: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Popover; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/popover/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/popover/styled.tsx":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/popover/styled.tsx ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   PopoverArrow: function() { return /* binding */ PopoverArrow; },
/* harmony export */   PopoverContainer: function() { return /* binding */ PopoverContainer; },
/* harmony export */   PopoverContent: function() { return /* binding */ PopoverContent; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");


const PopoverContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: relative;
  display: inline-block;
`;
const PopoverContent = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: absolute;
  z-index: ${(props) => props.$contentZIndex ?? 1000};
  min-width: ${(props) => {
    if (props.$matchTriggerWidth && props.$triggerWidth) {
        return `${props.$triggerWidth}px`;
    }
    return props.$contentMinWidth ?? "128px";
}};
  max-width: ${(props) => {
    if (props.$matchTriggerWidth && props.$triggerWidth) {
        return `${props.$triggerWidth}px`;
    }
    return props.$contentMaxWidth ?? "none";
}};
  width: ${(props) => {
    if (props.$matchTriggerWidth && props.$triggerWidth) {
        return `${props.$triggerWidth}px`;
    }
    return "auto";
}};
  background: ${(props) => props.$contentBackground ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.white};
  border: 1px solid ${(props) => props.$contentBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[200]};
  border-radius: ${(props) => props.$contentBorderRadius ?? "6px"};
  box-shadow: ${(props) => props.$contentBoxShadow ??
    "0 4px 6px -1px rgb(0 0 0 / 0.1), 0 2px 4px -2px rgb(0 0 0 / 0.1)"};
  padding: ${(props) => props.$contentPadding ?? "8px"};
  overflow: hidden;

  ${(props) => {
    switch (props.$placement) {
        case "bottom-start":
            return `
          top: 100%;
          left: 0;
          margin-top: 4px;
        `;
        case "bottom-end":
            return `
          top: 100%;
          right: 0;
          margin-top: 4px;
        `;
        case "top-start":
            return `
          bottom: 100%;
          left: 0;
          margin-bottom: 4px;
        `;
        case "top-end":
            return `
          bottom: 100%;
          right: 0;
          margin-bottom: 4px;
        `;
        default:
            return `
          top: 100%;
          left: 0;
          margin-top: 4px;
        `;
    }
}}
`;
const PopoverArrow = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: absolute;
  width: 8px;
  height: 8px;
  background: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.white};
  border: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[200]};
  border-radius: 2px;
  transform: rotate(45deg);
  pointer-events: none;
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/post-list/component.tsx":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/post-list/component.tsx ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   PostItem: function() { return /* binding */ PostItem; },
/* harmony export */   PostList: function() { return /* binding */ PostList; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/EyeIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/MagnifyingGlassIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PencilIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/PlusIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/Square2StackIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/TrashIcon.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _badge__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../badge */ "../../../../redfox-packages/core-components/src/components/badge/index.ts");
/* harmony import */ var _button__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _card__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _flex__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _flex_item__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../flex-item */ "../../../../redfox-packages/core-components/src/components/flex-item/index.ts");
/* harmony import */ var _input__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../input */ "../../../../redfox-packages/core-components/src/components/input/index.ts");
/* harmony import */ var _loading_spinner__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ../loading-spinner */ "../../../../redfox-packages/core-components/src/components/loading-spinner/index.ts");
/* harmony import */ var _modal__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ../modal */ "../../../../redfox-packages/core-components/src/components/modal/index.ts");
/* harmony import */ var _pagination__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ../pagination */ "../../../../redfox-packages/core-components/src/components/pagination/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/post-list/styled.tsx");














/**
 * Post Item Component
 *
 * Displays a single post item in the list
 *
 * @since 1.0.0
 */
const PostItem = ({ post, statusLabels, modifiedPrefix, actions = { edit: true, delete: true, duplicate: true, preview: true }, deleteModalTitle, deleteModalMessage, deleteConfirmButton, cancelButton, modalStrings, onEdit, onDelete, onDuplicate, onPreview, dateFormatter, className, testId, styleProps, }) => {
    const [isDeleteModalOpen, setIsDeleteModalOpen] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)(false);
    const handleEdit = () => {
        if (onEdit) {
            onEdit(post.id);
        }
    };
    const handleDelete = () => {
        setIsDeleteModalOpen(true);
    };
    const handleConfirmDelete = () => {
        if (onDelete) {
            onDelete(post.id);
        }
        setIsDeleteModalOpen(false);
    };
    const handleCancelDelete = () => {
        setIsDeleteModalOpen(false);
    };
    const handleDuplicate = () => {
        if (onDuplicate) {
            onDuplicate(post.id);
        }
    };
    const handlePreview = () => {
        if (onPreview) {
            onPreview(post.id);
        }
    };
    const formatDate = (dateString) => {
        if (dateFormatter) {
            return dateFormatter(dateString);
        }
        try {
            const date = new Date(dateString);
            return date.toLocaleDateString(undefined, {
                year: "numeric",
                month: "short",
                day: "numeric",
            });
        }
        catch {
            return dateString;
        }
    };
    const getStatusColor = (status) => {
        switch (status.toLowerCase()) {
            case "publish":
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.success;
            case "draft":
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[400];
            case "pending":
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.cyan[600];
            case "private":
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.primary[300];
            case "future":
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[700];
            default:
                return _colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[500];
        }
    };
    const getStatusLabel = (status) => {
        const statusKey = status.toLowerCase();
        return (statusLabels[statusKey] ||
            status.charAt(0).toUpperCase() + status.slice(1));
    };
    const buttonStyleProps = {
        backgroundColor: "transparent",
        color: _colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[800],
        borderWidth: "0",
        borderRadius: "5px",
        width: "32px",
        height: "32px",
        padding: "0",
        hoverBoxShadow: `0px 4px 10px ${_colors__WEBPACK_IMPORTED_MODULE_8__.colors.primary[100]}`,
        hoverBackgroundColor: "transparent",
        hoverColor: _colors__WEBPACK_IMPORTED_MODULE_8__.colors.primary[300],
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_18__.StyledPostItem, { "$styleProps": styleProps, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_11__.Card, { styleProps: {
                    padding: styleProps?.padding || "13px 20px",
                    border: `1px solid ${styleProps?.borderColor || _colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[100]}`,
                    radius: styleProps?.borderRadius || "5px",
                }, ...(className && { className }), ...(testId && { testId }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { justify: "space-between", align: "center", children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_18__.Title, { "$styleProps": styleProps, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_18__.TitleLink, { onClick: handleEdit, children: post.title.rendered }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_badge__WEBPACK_IMPORTED_MODULE_9__.Badge, { variant: "solid", size: "small", styleProps: {
                                                backgroundColor: getStatusColor(post.status),
                                                margin: "0 0 0 10px",
                                            }, children: getStatusLabel(post.status) })] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_18__.ModifiedDate, { "$styleProps": styleProps, children: [modifiedPrefix, " ", formatDate(post.modified)] })] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { gap: "5px", children: [actions.edit !== false && onEdit && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handleEdit, styleProps: buttonStyleProps, testId: "post-item-edit", children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { width: 16, height: 16 }) })), actions.duplicate !== false && onDuplicate && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handleDuplicate, styleProps: buttonStyleProps, testId: "post-item-duplicate", children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_5__["default"], { width: 16, height: 16 }) })), actions.preview !== false && onPreview && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handlePreview, styleProps: buttonStyleProps, testId: "post-item-preview", children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 16, height: 16 }) })), actions.delete !== false && onDelete && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handleDelete, styleProps: buttonStyleProps, testId: "post-item-delete", children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_6__["default"], { width: 16, height: 16 }) }))] }) })] }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_modal__WEBPACK_IMPORTED_MODULE_16__.Modal, { isOpen: isDeleteModalOpen, onClose: handleCancelDelete, title: deleteModalTitle, strings: modalStrings, footer: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { gap: "10px", justify: "flex-end", children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { variant: "outline", onClick: handleCancelDelete, children: cancelButton }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handleConfirmDelete, styleProps: {
                                backgroundColor: _colors__WEBPACK_IMPORTED_MODULE_8__.colors.error,
                                hoverBackgroundColor: "#c53030",
                            }, children: deleteConfirmButton })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { children: deleteModalMessage }) })] }));
};
/**
 * Post List Component
 *
 * Displays a list of posts with search and filtering functionality
 *
 * @since 1.0.0
 */
const PostList = ({ posts, strings, loading = false, searchTerm = "", actions = { edit: true, delete: true, duplicate: true, preview: true }, pagination, onSearch, onAddNew, onEdit, onDelete, onDuplicate, onPreview, onPageChange, onItemsPerPageChange, showItemsPerPageSelector = true, itemsPerPageOptions = [10, 20, 50, 100], maxPageButtons = 7, showPageInfo = true, showFirstLastButtons = true, dateFormatter, className, testId, styleProps, }) => {
    const handleSearch = (e) => {
        if (onSearch) {
            onSearch(e.target.value);
        }
    };
    const handleClearSearch = () => {
        if (onSearch) {
            onSearch("");
        }
    };
    if (loading && posts.length === 0) {
        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_11__.Card, { center: true, styleProps: { padding: "30px" }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_loading_spinner__WEBPACK_IMPORTED_MODULE_15__.LoadingSpinner, {}) }));
    }
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { direction: "column", gap: "30px", ...(className && { className }), ...(testId && { testId }), children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { justify: "space-between", align: "center", children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_input__WEBPACK_IMPORTED_MODULE_14__.Input, { type: "text", placeholder: strings.searchPlaceholder, value: searchTerm, variant: "outline", startIcon: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 20, height: 20 }), onChange: handleSearch, testId: "post-list-search" }) }), onAddNew && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: onAddNew, testId: "post-list-add-new", children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_4__["default"], { width: 20, height: 20 }), strings.addNewButton] }) }))] }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: [posts.length === 0 && !loading ? ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_11__.Card, { center: true, styleProps: {
                            border: `1px dashed ${_colors__WEBPACK_IMPORTED_MODULE_8__.colors.gray[200]}`,
                            padding: "30px",
                            radius: "5px",
                        }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_flex__WEBPACK_IMPORTED_MODULE_12__.Flex, { direction: "column", gap: "5px", children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("span", { children: strings.noPostsFound }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: searchTerm ? ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)("span", { children: [strings.noSearchResults, " ", (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: handleClearSearch, variant: "link", size: "small", testId: "post-list-clear-search", children: strings.clearSearch }), "."] })) : ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("span", { children: onAddNew && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_button__WEBPACK_IMPORTED_MODULE_10__.Button, { onClick: onAddNew, variant: "link", size: "small", testId: "post-list-create-first", children: strings.createFirstPost }), "."] })) })) })] }) })) : ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_18__.StyledPostList, { "$styleProps": styleProps, children: posts.map((post) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(PostItem, { post: post, statusLabels: strings.statusLabels, modifiedPrefix: strings.modifiedPrefix, actions: actions, editLabel: strings.editLabel, deleteModalTitle: strings.deleteModalTitle, deleteModalMessage: strings.deleteModalMessage, deleteConfirmButton: strings.deleteConfirmButton, cancelButton: strings.cancelButton, modalStrings: strings.modalStrings, onEdit: onEdit, onDelete: onDelete, onDuplicate: onDuplicate, onPreview: onPreview, dateFormatter: dateFormatter }, post.id))) })), loading && posts.length > 0 && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_11__.Card, { center: true, styleProps: { padding: "20px 0 0" }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_loading_spinner__WEBPACK_IMPORTED_MODULE_15__.LoadingSpinner, {}) }))] }), pagination && pagination.totalPages > 1 && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_flex_item__WEBPACK_IMPORTED_MODULE_13__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_pagination__WEBPACK_IMPORTED_MODULE_17__.Pagination, { currentPage: pagination.currentPage, totalPages: pagination.totalPages, totalItems: pagination.totalItems, itemsPerPage: pagination.itemsPerPage, strings: strings.pagination, onPageChange: onPageChange || (() => { }), onItemsPerPageChange: onItemsPerPageChange, showItemsPerPageSelector: showItemsPerPageSelector, itemsPerPageOptions: itemsPerPageOptions, maxPageButtons: maxPageButtons, disabled: loading, showPageInfo: showPageInfo, showFirstLastButtons: showFirstLastButtons }) }))] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/post-list/index.ts":
/*!*************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/post-list/index.ts ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   PostItem: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.PostItem; },
/* harmony export */   PostList: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.PostList; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/post-list/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/post-list/styled.tsx":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/post-list/styled.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   ModifiedDate: function() { return /* binding */ ModifiedDate; },
/* harmony export */   StyledPostItem: function() { return /* binding */ StyledPostItem; },
/* harmony export */   StyledPostList: function() { return /* binding */ StyledPostList; },
/* harmony export */   Title: function() { return /* binding */ Title; },
/* harmony export */   TitleLink: function() { return /* binding */ TitleLink; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");


/**
 * Styled container for post list
 *
 * @since 1.0.0
 */
const StyledPostList = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  flex-direction: column;
  gap: 10px;

  ${({ $styleProps }) => $styleProps &&
    `
    ${$styleProps.backgroundColor ? `background-color: ${$styleProps.backgroundColor};` : ""}
    ${$styleProps.padding ? `padding: ${$styleProps.padding};` : ""}
    ${$styleProps.borderRadius ? `border-radius: ${$styleProps.borderRadius};` : ""}
    ${$styleProps.gap ? `gap: ${$styleProps.gap};` : ""}
  `}
`;
/**
 * Styled post item wrapper
 *
 * @since 1.0.0
 */
const StyledPostItem = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  ${({ $styleProps }) => $styleProps &&
    `
    ${$styleProps.backgroundColor ? `background-color: ${$styleProps.backgroundColor};` : ""}
    ${$styleProps.borderColor ? `border-color: ${$styleProps.borderColor};` : ""}
    ${$styleProps.padding ? `padding: ${$styleProps.padding};` : ""}
    ${$styleProps.borderRadius ? `border-radius: ${$styleProps.borderRadius};` : ""}
  `}
`;
/**
 * Styled title
 *
 * @since 1.0.0
 */
const Title = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].h3 `
  margin: 0;
  font-size: 16px;
  font-weight: 600;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[900]};
  display: flex;
  align-items: center;
  gap: 10px;

  ${({ $styleProps }) => $styleProps &&
    `
    ${$styleProps.titleColor ? `color: ${$styleProps.titleColor};` : ""}
    ${$styleProps.titleFontSize ? `font-size: ${$styleProps.titleFontSize};` : ""}
    ${$styleProps.titleFontWeight ? `font-weight: ${$styleProps.titleFontWeight};` : ""}
  `}
`;
/**
 * Styled title link
 *
 * @since 1.0.0
 */
const TitleLink = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  cursor: pointer;
  color: inherit;
  text-decoration: none;
  transition: color 0.2s ease;

  &:hover {
    color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
  }
`;
/**
 * Styled modified date
 *
 * @since 1.0.0
 */
const ModifiedDate = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].p `
  margin: 5px 0 0 0;
  font-size: 13px;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[600]};

  ${({ $styleProps }) => $styleProps &&
    `
    ${$styleProps.dateColor ? `color: ${$styleProps.dateColor};` : ""}
    ${$styleProps.dateFontSize ? `font-size: ${$styleProps.dateFontSize};` : ""}
  `}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/select/component.tsx":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/select/component.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Select: function() { return /* binding */ Select; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/CheckIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/ChevronDownIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/outline */ "../../../../redfox-packages/core-components/node_modules/@heroicons/react/24/outline/esm/XMarkIcon.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var _popover__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../popover */ "../../../../redfox-packages/core-components/src/components/popover/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/select/styled.tsx");





// Basic constants for simple virtualization
// const OPTION_HEIGHT_PX = 36; // fixed row height for list virtualization
// const VISIBLE_ROWS = 8; // number of rows visible without scroll
// const OVERSCAN_ROWS = 6; // extra rows to render above/below
function normalize(text) {
    return text.toLowerCase();
}
const Select = ({ options, value, defaultValue, onChange, multi = false, searchable = true, placeholder = "Select…", searchPlaceholder = "Search…", disabled = false, size = "medium", clearable = true, maxVisibleTags = 3, noOptionsText = "No options", className, testId, styleProps, }) => {
    const isControlled = typeof value !== "undefined";
    const [internalValue, setInternalValue] = react__WEBPACK_IMPORTED_MODULE_4___default().useState(() => {
        if (Array.isArray(defaultValue))
            return defaultValue;
        if (typeof defaultValue === "string")
            return defaultValue ? [defaultValue] : [];
        return [];
    });
    const selectedValues = react__WEBPACK_IMPORTED_MODULE_4___default().useMemo(() => {
        if (isControlled) {
            if (Array.isArray(value))
                return value;
            if (typeof value === "string")
                return value ? [value] : [];
            return [];
        }
        return internalValue;
    }, [isControlled, value, internalValue]);
    const [open, setOpen] = react__WEBPACK_IMPORTED_MODULE_4___default().useState(false);
    const [query, setQuery] = react__WEBPACK_IMPORTED_MODULE_4___default().useState("");
    const [activeIndex, setActiveIndex] = react__WEBPACK_IMPORTED_MODULE_4___default().useState(-1);
    const fieldRef = react__WEBPACK_IMPORTED_MODULE_4___default().useRef(null);
    const listRef = react__WEBPACK_IMPORTED_MODULE_4___default().useRef(null);
    const inputRef = react__WEBPACK_IMPORTED_MODULE_4___default().useRef(null);
    const searchInputRef = react__WEBPACK_IMPORTED_MODULE_4___default().useRef(null);
    const valueSet = react__WEBPACK_IMPORTED_MODULE_4___default().useMemo(() => new Set(selectedValues), [selectedValues]);
    const filtered = react__WEBPACK_IMPORTED_MODULE_4___default().useMemo(() => {
        if (!query.trim())
            return options;
        const q = normalize(query);
        return options.filter((opt) => normalize(opt.label).includes(q));
    }, [options, query]);
    const selectedOptions = react__WEBPACK_IMPORTED_MODULE_4___default().useMemo(() => options.filter((o) => valueSet.has(o.value)), [options, valueSet]);
    const setValue = (next) => {
        if (!isControlled)
            setInternalValue(next);
        onChange?.(multi ? next : (next[0] ?? ""), options.filter((o) => next.includes(o.value)));
    };
    const toggleValue = (val) => {
        if (multi) {
            const next = valueSet.has(val)
                ? selectedValues.filter((v) => v !== val)
                : [...selectedValues, val];
            setValue(next);
        }
        else {
            const next = [val];
            setValue(next);
            setOpen(false);
        }
        setQuery("");
        setActiveIndex(-1);
    };
    const clearAll = () => {
        setValue([]);
        setQuery("");
        setActiveIndex(-1);
    };
    // Keyboard navigation
    const moveActive = (delta) => {
        if (!filtered.length)
            return;
        const start = activeIndex < 0 ? 0 : activeIndex;
        let next = start + delta;
        if (next < 0)
            next = filtered.length - 1;
        if (next >= filtered.length)
            next = 0;
        setActiveIndex(next);
        // Ensure visible
        requestAnimationFrame(() => {
            const el = listRef.current?.querySelector(`[data-index="${next}"]`);
            el?.scrollIntoView({ block: "nearest" });
        });
    };
    const handleKeyDown = (e) => {
        if (!open &&
            (e.key === "ArrowDown" ||
                e.key === "ArrowUp" ||
                e.key === "Enter" ||
                e.key === " ")) {
            setOpen(true);
            requestAnimationFrame(() => {
                // Focus the search input in the dropdown when opening
                if (searchable) {
                    const inputToFocus = multi
                        ? searchInputRef.current
                        : inputRef.current;
                    inputToFocus?.focus();
                }
            });
            e.preventDefault();
            return;
        }
        switch (e.key) {
            case "ArrowDown":
                moveActive(1);
                e.preventDefault();
                break;
            case "ArrowUp":
                moveActive(-1);
                e.preventDefault();
                break;
            case "Home":
                setActiveIndex(0);
                e.preventDefault();
                break;
            case "End":
                setActiveIndex(filtered.length - 1);
                e.preventDefault();
                break;
            case "Enter":
            case " ":
                if (open && activeIndex >= 0 && activeIndex < filtered.length) {
                    const opt = filtered[activeIndex];
                    if (opt && !opt.disabled)
                        toggleValue(opt.value);
                    e.preventDefault();
                }
                else {
                    setOpen((o) => !o);
                    e.preventDefault();
                }
                break;
            case "Escape":
                setOpen(false);
                e.preventDefault();
                break;
            case "Backspace":
                if (multi && !query && selectedValues.length) {
                    setValue(selectedValues.slice(0, -1));
                    e.preventDefault();
                }
                break;
            default:
                break;
        }
    };
    // Handle keyboard events specifically for search inputs
    const handleSearchKeyDown = (e) => {
        switch (e.key) {
            case "ArrowDown":
                moveActive(1);
                e.preventDefault();
                break;
            case "ArrowUp":
                moveActive(-1);
                e.preventDefault();
                break;
            case "Home":
                setActiveIndex(0);
                e.preventDefault();
                break;
            case "End":
                setActiveIndex(filtered.length - 1);
                e.preventDefault();
                break;
            case "Enter":
            case " ":
                if (activeIndex >= 0 && activeIndex < filtered.length) {
                    const opt = filtered[activeIndex];
                    if (opt && !opt.disabled) {
                        toggleValue(opt.value);
                        e.preventDefault();
                    }
                }
                break;
            case "Escape":
                setOpen(false);
                e.preventDefault();
                break;
            default:
                // Allow normal text input behavior
                break;
        }
    };
    // Simple virtualization logic - variables kept for potential future implementation
    // const [scrollTop, setScrollTop] = React.useState(0);
    // const total = filtered.length;
    // const startIndexRaw = Math.max(0, Math.floor(scrollTop / OPTION_HEIGHT_PX) - OVERSCAN_ROWS);
    // const endIndexRaw = Math.min(
    //   total - 1,
    //   Math.floor((scrollTop + VISIBLE_ROWS * OPTION_HEIGHT_PX) / OPTION_HEIGHT_PX) + OVERSCAN_ROWS
    // );
    // const endIndex = Math.max(-1, endIndexRaw);
    // const startIndex = Math.min(startIndexRaw, Math.max(0, endIndex));
    // const itemsToRender = React.useMemo(
    //   () => (endIndex >= startIndex ? filtered.slice(startIndex, endIndex + 1) : []),
    //   [filtered, startIndex, endIndex]
    // );
    // const topSpacer = startIndex * OPTION_HEIGHT_PX;
    // const bottomSpacer = Math.max(0, (total - (endIndex + 1)) * OPTION_HEIGHT_PX);
    const listboxId = react__WEBPACK_IMPORTED_MODULE_4___default().useId();
    const panelKey = `${listboxId}-${query ? "q" : "noq"}`;
    const scrollOptionIntoCenter = react__WEBPACK_IMPORTED_MODULE_4___default().useCallback((index, retryCount = 0) => {
        if (!listRef.current || index < 0)
            return;
        const container = listRef.current;
        const el = container.querySelector(`[data-index="${index}"]`);
        if (!el && retryCount < 3) {
            // Element not ready yet, retry after a short delay
            setTimeout(() => scrollOptionIntoCenter(index, retryCount + 1), 10);
            return;
        }
        if (!el)
            return;
        const containerRect = container.getBoundingClientRect();
        const elRect = el.getBoundingClientRect();
        const offsetTop = elRect.top - containerRect.top + container.scrollTop;
        const target = offsetTop - container.clientHeight / 2 + el.clientHeight / 2;
        container.scrollTo({
            top: Math.max(0, target),
            behavior: "instant",
        });
    }, []);
    const renderSelectedSummary = () => {
        if (!multi)
            return null;
        const visible = selectedOptions.slice(0, maxVisibleTags);
        const hiddenCount = selectedOptions.length - visible.length;
        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [visible.map((opt) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.Tag, { "aria-label": `Selected ${opt.label}`, "$styleProps": styleProps, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.TagText, { children: opt.label }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.RemoveBtn, { type: "button", onClick: (e) => {
                                e.stopPropagation();
                                toggleValue(opt.value);
                            }, "aria-label": `Remove ${opt.label}`, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { width: 16, height: 16 }) })] }, opt.value))), hiddenCount > 0 && (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.Tag, { "$styleProps": styleProps, children: ["+", hiddenCount] })] }));
    };
    const showPlaceholder = selectedValues.length === 0 && !query;
    // Compute index of a selected option in the current filtered list
    const getSelectedIndexInFiltered = react__WEBPACK_IMPORTED_MODULE_4___default().useCallback(() => {
        if (filtered.length === 0)
            return -1;
        if (selectedValues.length === 0)
            return 0;
        // Prefer the first selected value for single, or the most recently added for multi
        const target = multi
            ? selectedValues[selectedValues.length - 1]
            : selectedValues[0];
        const idx = filtered.findIndex((o) => o.value === target);
        return idx >= 0 ? idx : 0;
    }, [filtered, selectedValues, multi]);
    // Handle dropdown opening - center selected option and focus search input
    react__WEBPACK_IMPORTED_MODULE_4___default().useEffect(() => {
        if (open) {
            const idx = selectedValues.length > 0 ? getSelectedIndexInFiltered() : 0;
            setActiveIndex(idx);
            requestAnimationFrame(() => {
                // Focus the search input in the dropdown for both single and multi select
                if (searchable) {
                    const inputToFocus = multi
                        ? searchInputRef.current
                        : inputRef.current;
                    inputToFocus?.focus();
                }
                if (selectedValues.length > 0) {
                    scrollOptionIntoCenter(idx);
                }
            });
        }
    }, [
        open,
        getSelectedIndexInFiltered,
        multi,
        searchable,
        selectedValues.length,
        scrollOptionIntoCenter,
    ]);
    // Ensure we start at top whenever query changes (but only when there's an actual search query)
    react__WEBPACK_IMPORTED_MODULE_4___default().useEffect(() => {
        if (query.trim()) {
            requestAnimationFrame(() => {
                if (listRef.current) {
                    listRef.current.scrollTop = 0;
                }
            });
        }
    }, [query]);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_popover__WEBPACK_IMPORTED_MODULE_5__.Popover, { open: open, onOpenChange: (o) => {
            setOpen(o);
            if (!o) {
                // Clear query so the next open shows all options
                setQuery("");
                setActiveIndex(-1);
                requestAnimationFrame(() => {
                    if (listRef.current)
                        listRef.current.scrollTop = 0;
                });
            }
        }, contentPadding: "0", contentBorderColor: styleProps?.borderColor, contentBorderRadius: styleProps?.borderRadius, contentZIndex: styleProps?.zIndex ?? 1000, placement: "bottom-start", matchTriggerWidth: true, trigger: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.Field, { ref: fieldRef, className: className, "data-testid": testId, role: "combobox", "aria-haspopup": "listbox", "aria-expanded": open, "aria-controls": listboxId, "aria-activedescendant": activeIndex >= 0 ? `${listboxId}-opt-${activeIndex}` : undefined, "aria-disabled": disabled, tabIndex: disabled ? -1 : 0, onKeyDown: handleKeyDown, onClick: (e) => {
                if (disabled)
                    return;
                // Prevent double-toggling by stopping propagation here
                e.stopPropagation();
                setOpen(!open);
            }, "$size": size, "$styleProps": styleProps, "$multi": multi, "$hasSelections": selectedValues.length > 0, "$open": open, children: [multi && renderSelectedSummary(), !multi && selectedOptions[0] && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.SelectedText, { "$styleProps": styleProps, children: selectedOptions[0].label })), !multi && searchable && !selectedOptions[0] && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.Placeholder, { children: placeholder })), multi && selectedValues.length === 0 && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.Placeholder, { children: placeholder })), !searchable && showPlaceholder && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.Placeholder, { children: placeholder })), clearable &&
                    selectedValues.length > 0 &&
                    !(open && query && !multi) && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.ClearBtn, { type: "button", "aria-label": "Clear selection", onClick: (e) => {
                        e.stopPropagation();
                        clearAll();
                    }, "$multi": multi, "$hasSelections": selectedValues.length > 0, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { width: 16, height: 16 }) })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.DropdownIcon, { "$open": open, "$disabled": disabled, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 16, height: 16 }) })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.Panel, { "$styleProps": styleProps, children: [searchable && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.SearchContainer, { "$size": size, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.SearchInput, { ref: multi ? searchInputRef : inputRef, value: query, onChange: (e) => {
                                setQuery(e.target.value);
                                setActiveIndex(0);
                            }, onKeyDown: handleSearchKeyDown, placeholder: searchPlaceholder, "aria-autocomplete": "list", "aria-controls": listboxId, "aria-expanded": open, "$styleProps": styleProps, "$size": size }), clearable && query && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.ClearBtn, { type: "button", "aria-label": "Clear search", onClick: (e) => {
                                e.stopPropagation();
                                setQuery("");
                                setActiveIndex(-1);
                                // Focus back to the search input
                                requestAnimationFrame(() => {
                                    const inputToFocus = multi
                                        ? searchInputRef.current
                                        : inputRef.current;
                                    inputToFocus?.focus();
                                });
                            }, "$multi": multi, "$hasSelections": false, style: {
                                position: "absolute",
                                right: "8px",
                                top: "50%",
                                transform: "translateY(-50%)",
                                zIndex: 1,
                            }, children: "\u2715" }))] })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.Dropdown, { ref: listRef, id: listboxId, role: "listbox", "aria-multiselectable": multi || undefined, "$styleProps": styleProps, "$size": size, children: [filtered.length === 0 && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.OptionRow, { "$disabled": true, "$active": false, "$selected": false, "$styleProps": styleProps, "$size": size, "aria-disabled": true, children: noOptionsText })), filtered.map((opt, actualIndex) => {
                            const selected = valueSet.has(opt.value);
                            const active = actualIndex === activeIndex;
                            const id = `${listboxId}-opt-${actualIndex}`;
                            return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_6__.OptionRow, { "data-index": actualIndex, id: id, role: "option", "aria-selected": selected, "$active": active, "$selected": selected, "$disabled": !!opt.disabled, "$styleProps": styleProps, "$size": size, onMouseEnter: () => setActiveIndex(actualIndex), onClick: () => !opt.disabled && toggleValue(opt.value), children: [opt.label, selected && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_6__.Check, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 16, height: 16 }) }))] }, opt.value));
                        })] })] }, panelKey) }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/select/index.ts":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/select/index.ts ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Select: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Select; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/select/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/select/select-styles.ts":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/select/select-styles.ts ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getSelectDropdownStyles: function() { return /* binding */ getSelectDropdownStyles; },
/* harmony export */   getSelectFieldStyles: function() { return /* binding */ getSelectFieldStyles; },
/* harmony export */   getSelectOptionStyles: function() { return /* binding */ getSelectOptionStyles; },
/* harmony export */   getSelectPanelStyles: function() { return /* binding */ getSelectPanelStyles; },
/* harmony export */   getSelectSearchContainerStyles: function() { return /* binding */ getSelectSearchContainerStyles; },
/* harmony export */   getSelectSearchInputStyles: function() { return /* binding */ getSelectSearchInputStyles; },
/* harmony export */   getSelectSizeStyles: function() { return /* binding */ getSelectSizeStyles; },
/* harmony export */   getSelectTagStyles: function() { return /* binding */ getSelectTagStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default size styles - improved consistency with other components
const getSelectSizeStyles = (size) => {
    switch (size) {
        case "small":
            return `
        padding: 8px 44px 8px 12px;
        font-size: 0.9em;
        line-height: 20px;
        min-height: 32px;
      `;
        case "large":
            return `
        padding: 12px 48px 12px 16px;
        font-size: 1.2em;
        line-height: 28px;
        min-height: 48px;
      `;
        case "medium":
        default:
            return `
        padding: 10px 44px 10px 14px;
        font-size: 1em;
        line-height: 24px;
        min-height: 40px;
      `;
    }
};
// Default field styles - enhanced with modern design patterns
const getSelectFieldStyles = (styleProps, isOpen) => {
    const { backgroundColor, borderColor, focusBorderColor, color, fontSize, borderRadius, padding, width, } = styleProps ?? {};
    return `
    background-color: ${backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
    border: 1px solid ${isOpen
        ? (focusBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300])
        : (borderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300])};
    border-radius: ${borderRadius ?? "6px"};
    color: ${color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[800]};
    font-weight: 400;
    ${fontSize ? `font-size: ${fontSize};` : ""}
    ${padding ? `padding: ${padding};` : ""}
    ${width ? `width: ${width};` : ""}
    transition: all 0.2s cubic-bezier(0.4, 0.0, 0.2, 1);

    &:hover:not(:disabled) {
      border-color: ${(() => {
        if (isOpen)
            return focusBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300];
        return borderColor ? `${borderColor}CC` : _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[400];
    })()};
    }

    &:focus-within {
      border-color: ${focusBorderColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
      outline: none;
    }

    &:disabled {
      background-color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[100]};
      color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[500]};
      border-color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[200]};
      cursor: not-allowed;
      opacity: 0.6;
    }
  `;
};
// Default panel styles - border and border-radius handled by Popover content props
const getSelectPanelStyles = (styleProps) => {
    const { backgroundColor, maxHeight } = styleProps ?? {};
    return `
    background-color: ${backgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
    max-height: ${maxHeight ?? "300px"};
    overflow: hidden;
  `;
};
// Default dropdown styles - enhanced with better scrolling and spacing
const getSelectDropdownStyles = (styleProps, size) => {
    const { maxHeight } = styleProps ?? {};
    // Size-based padding
    const getPadding = () => {
        switch (size) {
            case "small":
                return "0 0 4px 0";
            case "large":
                return "0 0 12px 0";
            case "medium":
            default:
                return "0 0 8px 0";
        }
    };
    return `
    max-height: ${maxHeight ?? "240px"};
    overflow-y: auto;
    padding: ${getPadding()};
  `;
};
// Default option styles - enhanced with modern interactions and typography
const getSelectOptionStyles = (active, selected, disabled, styleProps, size) => {
    const { optionHoverBackgroundColor, selectedOptionBackgroundColor, color } = styleProps ?? {};
    // Size-based styles
    const getSizeStyles = () => {
        switch (size) {
            case "small":
                return `
          padding: 8px 12px;
          font-size: 0.9em;
          line-height: 20px;
        `;
            case "large":
                return `
          padding: 16px 20px;
          font-size: 1.2em;
          line-height: 24px;
        `;
            case "medium":
            default:
                return `
          padding: 12px 16px;
          font-size: 1em;
          line-height: 20px;
        `;
        }
    };
    let styles = `
    ${getSizeStyles()}
    cursor: pointer;
    color: ${color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[700]};
    display: flex;
    align-items: center;
    justify-content: space-between;
    font-weight: 400;
    transition: background-color 0.1s ease-in-out;
    border-radius: 0;
    margin: 0;
    position: relative;
  `;
    if (disabled) {
        styles += `
      opacity: 0.5;
      cursor: not-allowed;
      color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[400]};
    `;
    }
    else {
        if (active && !selected) {
            styles += `
        background-color: ${optionHoverBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[50]};
        color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
      `;
        }
        if (selected) {
            styles += `
        background-color: ${selectedOptionBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[50]};
        color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        font-weight: 500;
      `;
        }
        if (!active && !selected) {
            styles += `
        &:hover {
          background-color: ${optionHoverBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[50]};
          color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
        }
      `;
        }
    }
    return styles;
};
// Default search input styles - size-based styling
const getSelectSearchInputStyles = (styleProps, size) => {
    const { color } = styleProps ?? {};
    // Size-based styles
    const getSizeStyles = () => {
        switch (size) {
            case "small":
                return `
          height: 28px;
          padding: 0 8px;
          font-size: 0.9em;
        `;
            case "large":
                return `
          height: 40px;
          padding: 0 12px;
          font-size: 1.2em;
        `;
            case "medium":
            default:
                return `
          height: 32px;
          padding: 0 8px;
          font-size: 1em;
        `;
        }
    };
    return `
    width: 100%;
    ${getSizeStyles()}
    border: none;
    border-radius: 0;
    outline: none;
    color: ${color ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[600]};
    background: transparent;
    transition: none;
    font-weight: 400;

    &::placeholder { 
      color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[400]};
      font-weight: 400;
    }
    
    &:focus { 
      outline: none;
      border: none;
      box-shadow: none;
    }

    &:hover {
      outline: none;
      border: none;
    }
  `;
};
// Default search container styles - size-based padding
const getSelectSearchContainerStyles = (size) => {
    // Size-based padding
    const getPadding = () => {
        switch (size) {
            case "small":
                return "8px";
            case "large":
                return "16px";
            case "medium":
            default:
                return "12px";
        }
    };
    return `
    padding: ${getPadding()};
    border-bottom: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[200]};
    background: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.white};
  `;
};
// Default tag styles - enhanced with modern badge design
const getSelectTagStyles = (styleProps) => {
    const { tagBackgroundColor, tagColor, borderRadius } = styleProps ?? {};
    return `
    background-color: ${tagBackgroundColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[100]};
    color: ${tagColor ?? _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]};
    border: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]}30;
    border-radius: ${borderRadius ?? "6px"};
    padding: 4px 8px;
    font-size: 1em;
    font-weight: 500;
    display: inline-flex;
    align-items: center;
    gap: 6px;
    margin: 2px 2px 2px 0;
    transition: all 0.15s ease-in-out;
    max-width: calc(100% - 64px);
    min-width: 0;
    flex-shrink: 0;
    
    &:hover {
      background-color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]}20;
      border-color: ${_colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300]}50;
    }
  `;
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/select/styled.tsx":
/*!************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/select/styled.tsx ***!
  \************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Check: function() { return /* binding */ Check; },
/* harmony export */   ClearBtn: function() { return /* binding */ ClearBtn; },
/* harmony export */   Dropdown: function() { return /* binding */ Dropdown; },
/* harmony export */   DropdownIcon: function() { return /* binding */ DropdownIcon; },
/* harmony export */   Field: function() { return /* binding */ Field; },
/* harmony export */   OptionRow: function() { return /* binding */ OptionRow; },
/* harmony export */   Panel: function() { return /* binding */ Panel; },
/* harmony export */   Placeholder: function() { return /* binding */ Placeholder; },
/* harmony export */   RemoveBtn: function() { return /* binding */ RemoveBtn; },
/* harmony export */   SearchContainer: function() { return /* binding */ SearchContainer; },
/* harmony export */   SearchInput: function() { return /* binding */ SearchInput; },
/* harmony export */   SelectedText: function() { return /* binding */ SelectedText; },
/* harmony export */   Tag: function() { return /* binding */ Tag; },
/* harmony export */   TagText: function() { return /* binding */ TagText; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _select_styles__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./select-styles */ "../../../../redfox-packages/core-components/src/components/select/select-styles.ts");



const Field = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: relative;
  display: flex;
  align-items: ${({ $multi, $hasSelections }) => $multi && $hasSelections ? "flex-start" : "center"};
  flex-wrap: ${({ $multi }) => ($multi ? "wrap" : "nowrap")};
  gap: 4px;
  width: ${({ $styleProps }) => $styleProps?.width ?? "100%"} !important;
  max-width: ${({ $styleProps }) => $styleProps?.width ?? "100%"} !important;
  min-width: ${({ $styleProps }) => $styleProps?.width ?? "auto"} !important;
  box-sizing: border-box;
  cursor: pointer;
  transition: all 0.2s ease-in-out;
  overflow: hidden; /* Prevent content from expanding the field */
  flex-shrink: 0; /* Prevent the field from shrinking */
  /* Reserve space for icons dynamically */

  ${({ $size, $styleProps }) => {
    // If custom padding is provided, don't use default size styles
    if ($styleProps?.padding)
        return "";
    // Use consistent padding regardless of selections since icons are absolutely positioned
    const basePadding = (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectSizeStyles)($size);
    // Always reserve space for both dropdown icon and clear button
    switch ($size) {
        case "small":
            return basePadding.replace("padding: 8px 44px 8px 12px", "padding: 8px 72px 8px 12px");
        case "large":
            return basePadding.replace("padding: 12px 48px 12px 16px", "padding: 12px 76px 12px 16px");
        case "medium":
        default:
            return basePadding.replace("padding: 10px 44px 10px 14px", "padding: 10px 72px 10px 14px");
    }
}}

  ${({ $styleProps, $open }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectFieldStyles)($styleProps, $open)}
`;
const Tag = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  display: inline-flex;
  align-items: center;
  gap: 4px;
  font-size: 1me;
  flex-shrink: 0; /* Prevent tags from shrinking too much */
  max-width: 100%; /* Ensure tags don't exceed container width */

  ${({ $styleProps }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectTagStyles)($styleProps)}
`;
const TagText = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  flex: 1 1 0;
  min-width: 0;
  text-overflow: ellipsis;
  overflow: hidden;
  white-space: nowrap;
`;
const RemoveBtn = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  border: 0;
  background: transparent;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
  cursor: pointer;
  padding: 0;
  line-height: 1;
  width: 18px;
  height: 18px;
  display: inline-flex;
  align-items: center;
  justify-content: center;
  border-radius: 50%;
  font-size: 1em;
  font-weight: 600;
  transition: all 0.15s ease-in-out;
  opacity: 0.7;

  &:hover {
    background: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]}20;
    color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[600]};
    opacity: 1;
    transform: scale(1.1);
  }

  &:active {
    transform: scale(0.95);
  }
`;
const Panel = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  width: 100%;
  display: flex;
  flex-direction: column;

  ${({ $styleProps }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectPanelStyles)($styleProps)}
`;
const SearchContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: relative;
  ${({ $size }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectSearchContainerStyles)($size)}
`;
const SearchInput = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].input `
  ${({ $styleProps, $size }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectSearchInputStyles)($styleProps, $size)}
`;
const Dropdown = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  width: 100%;
  flex: 1 1 auto;

  ${({ $styleProps, $size }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectDropdownStyles)($styleProps, $size)}
`;
const OptionRow = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  ${({ $active = false, $selected = false, $disabled = false, $styleProps, $size, }) => (0,_select_styles__WEBPACK_IMPORTED_MODULE_2__.getSelectOptionStyles)($active, $selected, $disabled, $styleProps, $size)}
`;
const Check = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  margin-left: auto;
  font-size: 1em;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
  font-weight: 500;
  display: flex;
  align-items: center;
  justify-content: center;
`;
const ClearBtn = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].button `
  border: 0;
  background: transparent;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500]};
  cursor: pointer;
  padding: 4px;
  line-height: 1;
  height: 28px;
  width: 28px;
  border-radius: 4px;
  display: flex;
  align-items: center;
  justify-content: center;
  transition: all 0.15s ease-in-out;
  font-size: 1em;
  font-weight: 600;
  flex-shrink: 0;
  position: absolute;
  right: 32px; /* Position to the left of the dropdown icon */
  top: 50%;
  transform: translateY(-50%);

  &:hover {
    color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[700]};
  }

  &:active {
    transform: ${({ $multi, $hasSelections }) => $multi && $hasSelections
    ? "scale(0.95)"
    : "translateY(-50%) scale(0.95)"};
  }
`;
const Placeholder = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[400]};
  font-weight: 400;
  flex: 1 1 0;
  min-width: 0;
  text-overflow: ellipsis;
  overflow: hidden;
  white-space: nowrap;
`;
const SelectedText = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  color: ${({ $styleProps }) => $styleProps?.color ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
  font-weight: 400;
  flex: 1 1 0;
  min-width: 0;
  text-overflow: ellipsis;
  overflow: hidden;
  white-space: nowrap;
`;
const DropdownIcon = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  position: absolute;
  right: 8px;
  top: 50%;
  transform: ${({ $open }) => $open
    ? "translateY(-50%) rotate(180deg)"
    : "translateY(-50%) rotate(0deg)"};
  display: flex;
  align-items: center;
  justify-content: center;
  width: 20px;
  height: 20px;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500]};
  transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
  opacity: ${({ $disabled }) => ($disabled ? 0.5 : 1)};
  flex-shrink: 0;
  pointer-events: none; /* Prevent clicks on the icon itself */

  svg {
    width: 16px;
    height: 16px;
    stroke-width: 2;
  }

  &:hover {
    color: ${({ $disabled }) => $disabled ? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500] : _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[700]};
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/sortable/component.tsx":
/*!*****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/sortable/component.tsx ***!
  \*****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Sortable: function() { return /* binding */ Sortable; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @dnd-kit/core */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/core/dist/core.esm.js");
/* harmony import */ var _dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @dnd-kit/sortable */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/sortable/dist/sortable.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _sortable_item__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./sortable-item */ "../../../../redfox-packages/core-components/src/components/sortable/sortable-item.tsx");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/sortable/styled.tsx");






const Sortable = ({ items, onReorder, renderItem, className, disabled = false, direction = "vertical", dragHandleSelector, animationDuration = 200, "aria-label": ariaLabel, onDragStart, onDragEnd, }) => {
    const [activeId, setActiveId] = (0,react__WEBPACK_IMPORTED_MODULE_3__.useState)(null);
    const sensors = (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useSensors)((0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useSensor)(_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.PointerSensor, {
        activationConstraint: {
            distance: 8,
        },
    }), (0,_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.useSensor)(_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.KeyboardSensor, {
        coordinateGetter: _dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__.sortableKeyboardCoordinates,
    }));
    const itemIds = (0,react__WEBPACK_IMPORTED_MODULE_3__.useMemo)(() => items.map((item) => item.id), [items]);
    const sortingStrategy = (0,react__WEBPACK_IMPORTED_MODULE_3__.useMemo)(() => direction === "horizontal"
        ? _dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__.horizontalListSortingStrategy
        : _dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__.verticalListSortingStrategy, [direction]);
    const handleDragStart = (event) => {
        if (disabled)
            return;
        const { active } = event;
        setActiveId(active.id);
        if (onDragStart) {
            const index = items.findIndex((item) => item.id === active.id);
            const item = items[index];
            if (item && index !== -1) {
                onDragStart(item, index);
            }
        }
    };
    const handleDragEnd = (event) => {
        const { active, over } = event;
        if (disabled || !over || active.id === over.id) {
            setActiveId(null);
            return;
        }
        const oldIndex = items.findIndex((item) => item.id === active.id);
        const newIndex = items.findIndex((item) => item.id === over.id);
        if (oldIndex !== -1 && newIndex !== -1 && oldIndex !== newIndex) {
            const newItems = (0,_dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__.arrayMove)(items, oldIndex, newIndex);
            onReorder(newItems);
        }
        if (onDragEnd) {
            const item = items[oldIndex];
            if (item && oldIndex !== -1) {
                onDragEnd(item, oldIndex);
            }
        }
        setActiveId(null);
    };
    const handleDragCancel = () => {
        setActiveId(null);
    };
    const ariaProps = {
        role: "list",
        "aria-label": ariaLabel || "Sortable list",
        "aria-live": "polite",
        "aria-atomic": "false",
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.DndContext, { sensors: sensors, collisionDetection: _dnd_kit_core__WEBPACK_IMPORTED_MODULE_1__.closestCenter, onDragStart: handleDragStart, onDragEnd: handleDragEnd, onDragCancel: handleDragCancel, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_2__.SortableContext, { items: itemIds, strategy: sortingStrategy, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_5__.SortableContainer, { className: className, direction: direction, disabled: disabled, animationDuration: animationDuration, ...ariaProps, children: items.map((item, index) => {
                    const isDragging = activeId === item.id;
                    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_sortable_item__WEBPACK_IMPORTED_MODULE_4__.SortableItem, { item: item, disabled: disabled, dragHandleSelector: dragHandleSelector, children: renderItem(item, index, isDragging) }, item.id));
                }) }) }) }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/sortable/index.ts":
/*!************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/sortable/index.ts ***!
  \************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   DragHandle: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_2__.DragHandle; },
/* harmony export */   Sortable: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Sortable; },
/* harmony export */   SortableContainer: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_2__.SortableContainer; },
/* harmony export */   SortableContent: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_2__.SortableContent; },
/* harmony export */   SortableItem: function() { return /* reexport safe */ _sortable_item__WEBPACK_IMPORTED_MODULE_1__.SortableItem; },
/* harmony export */   SortableItemContent: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_2__.SortableItemContent; },
/* harmony export */   SortableItemWrapper: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_2__.SortableItemWrapper; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/sortable/component.tsx");
/* harmony import */ var _sortable_item__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./sortable-item */ "../../../../redfox-packages/core-components/src/components/sortable/sortable-item.tsx");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/sortable/styled.tsx");





/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/sortable/sortable-item.tsx":
/*!*********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/sortable/sortable-item.tsx ***!
  \*********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   SortableItem: function() { return /* binding */ SortableItem; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @dnd-kit/sortable */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/sortable/dist/sortable.esm.js");
/* harmony import */ var _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @dnd-kit/utilities */ "../../../../redfox-packages/core-components/node_modules/@dnd-kit/utilities/dist/utilities.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/sortable/styled.tsx");





const SortableItem = ({ item, children, className, disabled = false, dragHandleSelector, }) => {
    const { attributes, listeners, setNodeRef, transform, transition, isDragging, isOver, setActivatorNodeRef, } = (0,_dnd_kit_sortable__WEBPACK_IMPORTED_MODULE_1__.useSortable)({
        id: item.id,
        disabled,
    });
    const style = {
        transform: _dnd_kit_utilities__WEBPACK_IMPORTED_MODULE_2__.CSS.Transform.toString(transform),
        transition,
    };
    const handleRef = (node) => {
        setNodeRef(node);
        if (node && dragHandleSelector) {
            const handle = node.querySelector(dragHandleSelector);
            if (handle) {
                setActivatorNodeRef(handle);
            }
        }
    };
    const dragListeners = dragHandleSelector ? {} : listeners;
    const dragAttributes = dragHandleSelector ? {} : attributes;
    react__WEBPACK_IMPORTED_MODULE_3___default().useEffect(() => {
        if (dragHandleSelector && setActivatorNodeRef) {
            const element = document.querySelector(`#sortable-item-${item.id} ${dragHandleSelector}`);
            if (element) {
                setActivatorNodeRef(element);
            }
        }
    }, [dragHandleSelector, item.id, setActivatorNodeRef]);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_4__.SortableItemWrapper, { ref: handleRef, id: `sortable-item-${item.id}`, className: className, "$isDragging": isDragging, "$isOver": isOver, "$transform": style.transform, "$transition": style.transition, disabled: disabled, role: "listitem", "aria-grabbed": isDragging, "aria-dropeffect": disabled ? "none" : "move", tabIndex: disabled ? -1 : 0, ...dragAttributes, ...dragListeners, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/sortable/styled.tsx":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/sortable/styled.tsx ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   DragHandle: function() { return /* binding */ DragHandle; },
/* harmony export */   SortableContainer: function() { return /* binding */ SortableContainer; },
/* harmony export */   SortableContent: function() { return /* binding */ SortableContent; },
/* harmony export */   SortableItemContent: function() { return /* binding */ SortableItemContent; },
/* harmony export */   SortableItemWrapper: function() { return /* binding */ SortableItemWrapper; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");



const fadeIn = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.keyframes) `
  from {
    opacity: 0;
  }
  to {
    opacity: 1;
  }
`;
const SortableContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  flex-direction: ${({ direction = "vertical" }) => direction === "horizontal" ? "row" : "column"};
  gap: 10px;

  ${({ direction = "vertical" }) => direction === "horizontal" &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      flex-wrap: wrap;
      align-items: flex-start;
    `}

  ${({ disabled }) => disabled &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.6;
      pointer-events: none;
    `}
  
  animation: ${fadeIn} ${({ animationDuration = 200 }) => animationDuration}ms ease-in-out;
`;
const SortableItemWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  position: relative;
  transform: ${({ $transform }) => $transform || "none"};
  transition: ${({ $transition }) => $transition || "none"};
  cursor: ${({ disabled }) => (disabled ? "default" : "grab")};

  ${({ $isDragging }) => $isDragging &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.5;
      cursor: grabbing;
      z-index: 1000;
    `}

  &:active {
    cursor: ${({ disabled }) => (disabled ? "default" : "grabbing")};
  }

  ${({ disabled }) => disabled &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.6;
      cursor: not-allowed;
    `}
`;
const DragHandle = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  align-items: center;
  justify-content: center;
  width: 24px;
  height: 24px;
  cursor: grab;
  color: ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[500]};
  transition: color 0.2s ease;

  &:hover {
    color: ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.cyan[600]};
  }

  &:active {
    cursor: grabbing;
  }

  svg {
    width: 16px;
    height: 16px;
  }
`;
const SortableContent = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  flex: 1;
  min-width: 0;
`;
const SortableItemContent = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  align-items: center;
  gap: 8px;
  padding: 8px;
  border-radius: 4px;
  border: 1px solid ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[200]};
  background: ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.white};
  transition: all 0.2s ease;

  &:hover {
    border-color: ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.primary[300]};
  }

  &:focus-within {
    outline: 2px solid ${_colors__WEBPACK_IMPORTED_MODULE_2__.colors.cyan[600]};
    outline-offset: 2px;
  }
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/tab-header/component.tsx":
/*!*******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/tab-header/component.tsx ***!
  \*******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabHeader: function() { return /* binding */ TabHeader; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _card__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/tab-header/styled.tsx");




const TabHeader = ({ title, description, styleProps, className, testId, ...props }) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_card__WEBPACK_IMPORTED_MODULE_2__.Card, { styleProps: {
            background: "white",
            padding: "30px",
            radius: "10px",
        }, className: className, testId: testId, ...props, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_3__.StyledTabHeaderContainer, { "$height": styleProps?.height, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_3__.StyledTabHeaderTitle, { "$titleColor": styleProps?.titleColor, children: title }), description && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_3__.StyledTabHeaderDescription, { "$descriptionColor": styleProps?.descriptionColor, children: description }))] }) }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/tab-header/index.ts":
/*!**************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/tab-header/index.ts ***!
  \**************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabHeader: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.TabHeader; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/tab-header/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/tab-header/styled.tsx":
/*!****************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/tab-header/styled.tsx ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledTabHeaderContainer: function() { return /* binding */ StyledTabHeaderContainer; },
/* harmony export */   StyledTabHeaderDescription: function() { return /* binding */ StyledTabHeaderDescription; },
/* harmony export */   StyledTabHeaderTitle: function() { return /* binding */ StyledTabHeaderTitle; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");


const StyledTabHeaderContainer = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  flex-direction: column;
  gap: 10px;
  height: ${({ $height }) => $height ?? "auto"};
`;
const StyledTabHeaderTitle = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].h2 `
  margin: 0;
  padding: 0;
  color: ${({ $titleColor }) => $titleColor ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
  font-size: 1.4em;
  font-weight: 600;
  line-height: 1.4;
`;
const StyledTabHeaderDescription = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].p `
  margin: 0;
  padding: 0;
  color: ${({ $descriptionColor }) => $descriptionColor ?? _colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[500]};
  font-size: 1em;
  line-height: 1.5;
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/toggle/component.tsx":
/*!***************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/toggle/component.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Toggle: function() { return /* binding */ Toggle; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./styled */ "../../../../redfox-packages/core-components/src/components/toggle/styled.tsx");
/* harmony import */ var _toggle_styles__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./toggle-styles */ "../../../../redfox-packages/core-components/src/components/toggle/toggle-styles.ts");




const Toggle = ({ checked, defaultChecked, onChange, size = "medium", label, description, labelPosition = "right", disabled = false, className, testId, styleProps, ...props }) => {
    const [internalChecked, setInternalChecked] = react__WEBPACK_IMPORTED_MODULE_1___default().useState(defaultChecked ?? false);
    const isControlled = checked !== undefined;
    const checkedValue = isControlled ? checked : internalChecked;
    const tokens = (0,_toggle_styles__WEBPACK_IMPORTED_MODULE_3__.getToggleSizeTokens)(size);
    const handleChange = (event) => {
        const newChecked = event.target.checked;
        if (!isControlled) {
            setInternalChecked(newChecked);
        }
        onChange?.(newChecked);
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_2__.Container, { "$disabled": disabled, "$labelPosition": labelPosition, className: className, "data-testid": testId, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.Track, { "$checked": checkedValue, "$disabled": disabled, "$trackWidth": tokens.trackWidth, "$trackHeight": tokens.trackHeight, "$thumbSize": tokens.thumb, "$translate": tokens.translate, "$styleProps": styleProps, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.Thumb, { "$checked": checkedValue, "$disabled": disabled, "$trackWidth": tokens.trackWidth, "$trackHeight": tokens.trackHeight, "$thumbSize": tokens.thumb, "$translate": tokens.translate, "$styleProps": styleProps }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.HiddenInput, { type: "checkbox", checked: checkedValue, onChange: handleChange, disabled: disabled, ...props }), (label || description) && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_2__.LabelContent, { children: [label && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.LabelText, { "$disabled": disabled, "$styleProps": styleProps, children: label })), description && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_2__.Description, { "$disabled": disabled, "$styleProps": styleProps, children: description }))] }))] }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/toggle/index.ts":
/*!**********************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/toggle/index.ts ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Toggle: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Toggle; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "../../../../redfox-packages/core-components/src/components/toggle/component.tsx");



/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/toggle/styled.tsx":
/*!************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/toggle/styled.tsx ***!
  \************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Container: function() { return /* binding */ Container; },
/* harmony export */   Description: function() { return /* binding */ Description; },
/* harmony export */   HiddenInput: function() { return /* binding */ HiddenInput; },
/* harmony export */   LabelContent: function() { return /* binding */ LabelContent; },
/* harmony export */   LabelText: function() { return /* binding */ LabelText; },
/* harmony export */   Thumb: function() { return /* binding */ Thumb; },
/* harmony export */   Track: function() { return /* binding */ Track; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "../../../../redfox-packages/core-components/node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _toggle_styles__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./toggle-styles */ "../../../../redfox-packages/core-components/src/components/toggle/toggle-styles.ts");


const Container = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].label `
  display: inline-flex;
  align-items: flex-start;
  gap: 12px;
  cursor: ${({ $disabled }) => ($disabled ? "not-allowed" : "pointer")};
  flex-direction: ${({ $labelPosition }) => $labelPosition === "left" ? "row-reverse" : "row"};
  user-select: none;
  -webkit-tap-highlight-color: transparent;

  &:focus-within {
    outline: none;
  }
`;
const Track = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  ${({ $checked, $disabled, $trackWidth, $trackHeight, $thumbSize, $translate, $styleProps, }) => {
    const tokens = {
        trackWidth: $trackWidth,
        trackHeight: $trackHeight,
        thumb: $thumbSize,
        translate: $translate,
    };
    return (0,_toggle_styles__WEBPACK_IMPORTED_MODULE_1__.getToggleTrackStyles)($checked, $disabled, tokens, $styleProps);
}}
`;
const Thumb = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  ${({ $checked, $disabled, $trackWidth, $trackHeight, $thumbSize, $translate, $styleProps, }) => {
    const tokens = {
        trackWidth: $trackWidth,
        trackHeight: $trackHeight,
        thumb: $thumbSize,
        translate: $translate,
    };
    return (0,_toggle_styles__WEBPACK_IMPORTED_MODULE_1__.getToggleThumbStyles)($checked, $disabled, tokens, $styleProps);
}}
`;
const HiddenInput = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].input `
  position: absolute;
  opacity: 0;
  pointer-events: none;
`;
const LabelContent = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  flex-direction: column;
  gap: 4px;
`;
const LabelText = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  ${({ $disabled, $styleProps }) => (0,_toggle_styles__WEBPACK_IMPORTED_MODULE_1__.getToggleLabelStyles)($disabled, $styleProps)}
`;
const Description = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  ${({ $disabled, $styleProps }) => (0,_toggle_styles__WEBPACK_IMPORTED_MODULE_1__.getToggleDescriptionStyles)($disabled, $styleProps)}
`;


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/components/toggle/toggle-styles.ts":
/*!******************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/components/toggle/toggle-styles.ts ***!
  \******************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getToggleDescriptionStyles: function() { return /* binding */ getToggleDescriptionStyles; },
/* harmony export */   getToggleLabelStyles: function() { return /* binding */ getToggleLabelStyles; },
/* harmony export */   getToggleSizeTokens: function() { return /* binding */ getToggleSizeTokens; },
/* harmony export */   getToggleThumbStyles: function() { return /* binding */ getToggleThumbStyles; },
/* harmony export */   getToggleTrackStyles: function() { return /* binding */ getToggleTrackStyles; }
/* harmony export */ });
/* harmony import */ var _colors__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../colors */ "../../../../redfox-packages/core-components/src/colors.ts");

// Default colors - improved design
const DEFAULT_COLORS = {
    primary: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[300],
    primaryHover: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.primary[600],
    uncheckedTrack: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[200],
    uncheckedTrackHover: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300],
    gray300: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[300],
    gray500: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[500],
    gray700: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.gray[700],
    white: _colors__WEBPACK_IMPORTED_MODULE_0__.colors.white,
    transparent: "transparent",
};
// Size tokens - improved proportions with proper spacing
const getToggleSizeTokens = (size) => {
    switch (size) {
        case "small":
            return {
                trackWidth: 36,
                trackHeight: 20,
                thumb: 16,
                translate: 16, // This will be calculated dynamically
            };
        case "large":
            return {
                trackWidth: 60,
                trackHeight: 34,
                thumb: 30,
                translate: 26, // This will be calculated dynamically
            };
        case "medium":
        default:
            return {
                trackWidth: 48,
                trackHeight: 26,
                thumb: 22,
                translate: 22, // This will be calculated dynamically
            };
    }
};
// Track styles
const getToggleTrackStyles = (checked, disabled, tokens, styleProps) => {
    const { trackBackgroundColor, checkedTrackBackgroundColor, focusRingColor, disabledOpacity, } = styleProps ?? {};
    const backgroundColor = checked
        ? (checkedTrackBackgroundColor ?? DEFAULT_COLORS.primary)
        : (trackBackgroundColor ?? DEFAULT_COLORS.uncheckedTrack);
    return `
    position: relative;
    width: ${tokens.trackWidth}px;
    height: ${tokens.trackHeight}px;
    background-color: ${backgroundColor};
    border: none;
    border-radius: ${tokens.trackHeight}px;
    transition: all 0.25s cubic-bezier(0.4, 0.0, 0.2, 1);
    cursor: ${disabled ? "not-allowed" : "pointer"};
    opacity: ${disabled ? (disabledOpacity ?? 0.6) : 1};
    box-sizing: border-box;
    box-shadow: ${checked ? "none" : "inset 0 1px 3px rgba(0, 0, 0, 0.15)"};
    
    &:hover {
      transform: ${disabled ? "none" : "scale(1.02)"};
    }

    &:focus-within {
      outline: 2px solid ${focusRingColor ?? DEFAULT_COLORS.primary}40;
      outline-offset: 2px;
      box-shadow: ${checked ? "0 0 0 4px rgba(59, 130, 246, 0.15)" : "inset 0 1px 3px rgba(0, 0, 0, 0.15), 0 0 0 4px rgba(59, 130, 246, 0.15)"};
    }
  `;
};
// Thumb styles
const getToggleThumbStyles = (checked, disabled, tokens, styleProps) => {
    const { thumbBackgroundColor } = styleProps ?? {};
    // Calculate proper spacing - ensure equal padding on both sides
    const padding = 2;
    const translateX = checked
        ? tokens.trackWidth - tokens.thumb - padding * 2
        : 0;
    return `
    position: absolute;
    top: 2px;
    left: 2px;
    width: ${tokens.thumb}px;
    height: ${tokens.thumb}px;
    background-color: ${thumbBackgroundColor ?? DEFAULT_COLORS.white};
    border-radius: 50%;
    transition: all 0.25s cubic-bezier(0.4, 0.0, 0.2, 1);
    transform: translateX(${translateX}px);
    box-shadow: ${checked
        ? "0 4px 12px rgba(0, 0, 0, 0.15), 0 2px 4px rgba(0, 0, 0, 0.1)"
        : "0 2px 8px rgba(0, 0, 0, 0.12), 0 1px 3px rgba(0, 0, 0, 0.08)"};
    box-sizing: border-box;
    
    &:hover {
      transform: translateX(${translateX}px) ${disabled ? "" : "scale(1.1)"};
    }
  `;
};
// Label styles
const getToggleLabelStyles = (disabled, styleProps) => {
    const { labelColor, disabledOpacity } = styleProps ?? {};
    return `
    color: ${labelColor ?? "inherit"};
    font-weight: 500;
    opacity: ${disabled ? (disabledOpacity ?? 0.5) : 1};
  `;
};
// Description styles
const getToggleDescriptionStyles = (_disabled, styleProps) => {
    const { descriptionColor, disabledOpacity } = styleProps ?? {};
    return `
    color: ${descriptionColor ?? DEFAULT_COLORS.gray500};
    font-size: 1em;
    opacity: ${_disabled ? (disabledOpacity ?? 0.5) : 1};
  `;
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/contexts/notification-context/context.tsx":
/*!*************************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/contexts/notification-context/context.tsx ***!
  \*************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationContext: function() { return /* binding */ NotificationContext; },
/* harmony export */   NotificationProvider: function() { return /* binding */ NotificationProvider; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "../../../../redfox-packages/core-components/node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);

/**
 * Notification Context
 *
 * React context for managing notifications across the application.
 *
 * @since 1.0.0
 */

/**
 * Notification context
 *
 * @since 1.0.0
 */
const NotificationContext = (0,react__WEBPACK_IMPORTED_MODULE_1__.createContext)(undefined);
/**
 * Notification context provider component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const NotificationProvider = ({ children, }) => {
    const [notifications, setNotifications] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)([]);
    /**
     * Remove a notification by ID
     *
     * @since 1.0.0
     *
     * @param id Notification ID to remove.
     *
     * @return void
     */
    const removeNotification = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((id) => {
        setNotifications((prev) => prev.filter((notification) => notification.id !== id));
    }, []);
    /**
     * Add a notification
     *
     * @since 1.0.0
     *
     * @param type Notification type.
     * @param message Notification message.
     * @param options Optional notification options.
     *
     * @return Notification ID.
     */
    const addNotification = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((type, message, options) => {
        const id = `notification-${Date.now()}-${Math.random()}`;
        const notification = {
            id,
            variant: type,
            message,
            dismissible: options?.dismissible ?? true,
            autoDismiss: options?.autoDismiss ?? true,
            duration: options?.duration ?? 5000,
        };
        setNotifications((prev) => [...prev, notification]);
        // Auto-dismiss if enabled
        if (notification.autoDismiss) {
            setTimeout(() => {
                removeNotification(id);
            }, notification.duration);
        }
        return id;
    }, [removeNotification]);
    /**
     * Clear all notifications
     *
     * @since 1.0.0
     *
     * @return void
     */
    const clearNotifications = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)(() => {
        setNotifications([]);
    }, []);
    const value = {
        notifications,
        addNotification,
        removeNotification,
        clearNotifications,
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(NotificationContext.Provider, { value: value, children: children }));
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/contexts/notification-context/hook.ts":
/*!*********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/contexts/notification-context/hook.ts ***!
  \*********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useNotification: function() { return /* binding */ useNotification; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _context__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./context */ "../../../../redfox-packages/core-components/src/contexts/notification-context/context.tsx");
/**
 * Use Notification Hook
 *
 * Custom hook for accessing notification context.
 *
 * @since 1.0.0
 */


/**
 * Use notification hook
 *
 * @since 1.0.0
 *
 * @return Notification context value.
 */
const useNotification = () => {
    const context = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(_context__WEBPACK_IMPORTED_MODULE_1__.NotificationContext);
    if (context === undefined) {
        throw new Error("useNotification must be used within a NotificationProvider");
    }
    return context;
};


/***/ }),

/***/ "../../../../redfox-packages/core-components/src/contexts/notification-context/index.ts":
/*!**********************************************************************************************!*\
  !*** ../../../../redfox-packages/core-components/src/contexts/notification-context/index.ts ***!
  \**********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationContext: function() { return /* reexport safe */ _context__WEBPACK_IMPORTED_MODULE_0__.NotificationContext; },
/* harmony export */   NotificationProvider: function() { return /* reexport safe */ _context__WEBPACK_IMPORTED_MODULE_0__.NotificationProvider; },
/* harmony export */   useNotification: function() { return /* reexport safe */ _hook__WEBPACK_IMPORTED_MODULE_1__.useNotification; }
/* harmony export */ });
/* harmony import */ var _context__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./context */ "../../../../redfox-packages/core-components/src/contexts/notification-context/context.tsx");
/* harmony import */ var _hook__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./hook */ "../../../../redfox-packages/core-components/src/contexts/notification-context/hook.ts");
/**
 * Notification Context
 *
 * Exports for notification context.
 *
 * @since 1.0.0
 */




/***/ }),

/***/ "./node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js":
/*!***********************************************************************************!*\
  !*** ./node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ createCache; }
/* harmony export */ });
/* harmony import */ var _emotion_sheet__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/sheet */ "./node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Enum.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Utility.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Parser.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Tokenizer.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Serializer.js");
/* harmony import */ var stylis__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! stylis */ "./node_modules/stylis/src/Middleware.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/weak-memoize */ "./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @emotion/memoize */ "./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");





var identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {
  var previous = 0;
  var character = 0;

  while (true) {
    previous = character;
    character = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)(); // &\f

    if (previous === 38 && character === 12) {
      points[index] = 1;
    }

    if ((0,stylis__WEBPACK_IMPORTED_MODULE_4__.token)(character)) {
      break;
    }

    (0,stylis__WEBPACK_IMPORTED_MODULE_4__.next)();
  }

  return (0,stylis__WEBPACK_IMPORTED_MODULE_4__.slice)(begin, stylis__WEBPACK_IMPORTED_MODULE_4__.position);
};

var toRules = function toRules(parsed, points) {
  // pretend we've started with a comma
  var index = -1;
  var character = 44;

  do {
    switch ((0,stylis__WEBPACK_IMPORTED_MODULE_4__.token)(character)) {
      case 0:
        // &\f
        if (character === 38 && (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)() === 12) {
          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings
          // stylis inserts \f after & to know when & where it should replace this sequence with the context selector
          // and when it should just concatenate the outer and inner selectors
          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here
          points[index] = 1;
        }

        parsed[index] += identifierWithPointTracking(stylis__WEBPACK_IMPORTED_MODULE_4__.position - 1, points, index);
        break;

      case 2:
        parsed[index] += (0,stylis__WEBPACK_IMPORTED_MODULE_4__.delimit)(character);
        break;

      case 4:
        // comma
        if (character === 44) {
          // colon
          parsed[++index] = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.peek)() === 58 ? '&\f' : '';
          points[index] = parsed[index].length;
          break;
        }

      // fallthrough

      default:
        parsed[index] += (0,stylis__WEBPACK_IMPORTED_MODULE_2__.from)(character);
    }
  } while (character = (0,stylis__WEBPACK_IMPORTED_MODULE_4__.next)());

  return parsed;
};

var getRules = function getRules(value, points) {
  return (0,stylis__WEBPACK_IMPORTED_MODULE_4__.dealloc)(toRules((0,stylis__WEBPACK_IMPORTED_MODULE_4__.alloc)(value), points));
}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11


var fixedElements = /* #__PURE__ */new WeakMap();
var compat = function compat(element) {
  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo
  // negative .length indicates that this rule has been already prefixed
  element.length < 1) {
    return;
  }

  var value = element.value;
  var parent = element.parent;
  var isImplicitRule = element.column === parent.column && element.line === parent.line;

  while (parent.type !== 'rule') {
    parent = parent.parent;
    if (!parent) return;
  } // short-circuit for the simplest case


  if (element.props.length === 1 && value.charCodeAt(0) !== 58
  /* colon */
  && !fixedElements.get(parent)) {
    return;
  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)
  // then the props has already been manipulated beforehand as they that array is shared between it and its "rule parent"


  if (isImplicitRule) {
    return;
  }

  fixedElements.set(element, true);
  var points = [];
  var rules = getRules(value, points);
  var parentRules = parent.props;

  for (var i = 0, k = 0; i < rules.length; i++) {
    for (var j = 0; j < parentRules.length; j++, k++) {
      element.props[k] = points[i] ? rules[i].replace(/&\f/g, parentRules[j]) : parentRules[j] + " " + rules[i];
    }
  }
};
var removeLabel = function removeLabel(element) {
  if (element.type === 'decl') {
    var value = element.value;

    if ( // charcode for l
    value.charCodeAt(0) === 108 && // charcode for b
    value.charCodeAt(2) === 98) {
      // this ignores label
      element["return"] = '';
      element.value = '';
    }
  }
};
var ignoreFlag = 'emotion-disable-server-rendering-unsafe-selector-warning-please-do-not-use-this-the-warning-exists-for-a-reason';

var isIgnoringComment = function isIgnoringComment(element) {
  return element.type === 'comm' && element.children.indexOf(ignoreFlag) > -1;
};

var createUnsafeSelectorsAlarm = function createUnsafeSelectorsAlarm(cache) {
  return function (element, index, children) {
    if (element.type !== 'rule' || cache.compat) return;
    var unsafePseudoClasses = element.value.match(/(:first|:nth|:nth-last)-child/g);

    if (unsafePseudoClasses) {
      var isNested = !!element.parent; // in nested rules comments become children of the "auto-inserted" rule and that's always the `element.parent`
      //
      // considering this input:
      // .a {
      //   .b /* comm */ {}
      //   color: hotpink;
      // }
      // we get output corresponding to this:
      // .a {
      //   & {
      //     /* comm */
      //     color: hotpink;
      //   }
      //   .b {}
      // }

      var commentContainer = isNested ? element.parent.children : // global rule at the root level
      children;

      for (var i = commentContainer.length - 1; i >= 0; i--) {
        var node = commentContainer[i];

        if (node.line < element.line) {
          break;
        } // it is quite weird but comments are *usually* put at `column: element.column - 1`
        // so we seek *from the end* for the node that is earlier than the rule's `element` and check that
        // this will also match inputs like this:
        // .a {
        //   /* comm */
        //   .b {}
        // }
        //
        // but that is fine
        //
        // it would be the easiest to change the placement of the comment to be the first child of the rule:
        // .a {
        //   .b { /* comm */ }
        // }
        // with such inputs we wouldn't have to search for the comment at all
        // TODO: consider changing this comment placement in the next major version


        if (node.column < element.column) {
          if (isIgnoringComment(node)) {
            return;
          }

          break;
        }
      }

      unsafePseudoClasses.forEach(function (unsafePseudoClass) {
        console.error("The pseudo class \"" + unsafePseudoClass + "\" is potentially unsafe when doing server-side rendering. Try changing it to \"" + unsafePseudoClass.split('-child')[0] + "-of-type\".");
      });
    }
  };
};

var isImportRule = function isImportRule(element) {
  return element.type.charCodeAt(1) === 105 && element.type.charCodeAt(0) === 64;
};

var isPrependedWithRegularRules = function isPrependedWithRegularRules(index, children) {
  for (var i = index - 1; i >= 0; i--) {
    if (!isImportRule(children[i])) {
      return true;
    }
  }

  return false;
}; // use this to remove incorrect elements from further processing
// so they don't get handed to the `sheet` (or anything else)
// as that could potentially lead to additional logs which in turn could be overhelming to the user


var nullifyElement = function nullifyElement(element) {
  element.type = '';
  element.value = '';
  element["return"] = '';
  element.children = '';
  element.props = '';
};

var incorrectImportAlarm = function incorrectImportAlarm(element, index, children) {
  if (!isImportRule(element)) {
    return;
  }

  if (element.parent) {
    console.error("`@import` rules can't be nested inside other rules. Please move it to the top level and put it before regular rules. Keep in mind that they can only be used within global styles.");
    nullifyElement(element);
  } else if (isPrependedWithRegularRules(index, children)) {
    console.error("`@import` rules can't be after other rules. Please put your `@import` rules before your other rules.");
    nullifyElement(element);
  }
};

/* eslint-disable no-fallthrough */

function prefix(value, length) {
  switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.hash)(value, length)) {
    // color-adjust
    case 5103:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'print-' + value + value;
    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)

    case 5737:
    case 4201:
    case 3177:
    case 3433:
    case 1641:
    case 4457:
    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break

    case 5572:
    case 6356:
    case 5844:
    case 3191:
    case 6645:
    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,

    case 6391:
    case 5879:
    case 5623:
    case 6135:
    case 4599:
    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)

    case 4215:
    case 6389:
    case 5109:
    case 5365:
    case 5621:
    case 3829:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + value;
    // appearance, user-select, transform, hyphens, text-size-adjust

    case 5349:
    case 4246:
    case 4810:
    case 6968:
    case 2756:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
    // flex, flex-direction

    case 6828:
    case 4268:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
    // order

    case 6165:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-' + value + value;
    // align-items

    case 5187:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(\w+).+(:[^]+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-$1$2' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-$1$2') + value;
    // align-self

    case 5443:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-item-' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /flex-|-self/, '') + value;
    // align-content

    case 4675:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-line-pack' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /align-content|flex-|-self/, '') + value;
    // flex-shrink

    case 5548:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'shrink', 'negative') + value;
    // flex-basis

    case 5292:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'basis', 'preferred-size') + value;
    // flex-grow

    case 6060:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-' + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, '-grow', '') + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'grow', 'positive') + value;
    // transition

    case 4554:
      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /([^-])(transform)/g, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2') + value;
    // cursor

    case 6187:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(zoom-|grab)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1'), /(image-set)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1'), value, '') + value;
    // background, background-image

    case 5495:
    case 3959:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(image-set\([^]*)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1' + '$`$1');
    // justify-content

    case 4968:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)(flex-)?(.*)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'box-pack:$3' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + value;
    // (margin|padding)-inline-(start|end)

    case 4095:
    case 3583:
    case 4068:
    case 2532:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+)-inline(.+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$1$2') + value;
    // (min|max)?(width|height|inline-size|block-size)

    case 8116:
    case 7059:
    case 5753:
    case 5535:
    case 5445:
    case 5701:
    case 4933:
    case 4677:
    case 5533:
    case 5789:
    case 5021:
    case 4765:
      // stretch, max-content, min-content, fill-available
      if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.strlen)(value) - 1 - length > 6) switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 1)) {
        // (m)ax-content, (m)in-content
        case 109:
          // -
          if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 4) !== 45) break;
        // (f)ill-available, (f)it-content

        case 102:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)(.+)-([^]+)/, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2-$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;
        // (s)tretch

        case 115:
          return ~(0,stylis__WEBPACK_IMPORTED_MODULE_2__.indexof)(value, 'stretch') ? prefix((0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, 'stretch', 'fill-available'), length) + value : value;
      }
      break;
    // position: sticky

    case 4949:
      // (s)ticky?
      if ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 1) !== 115) break;
    // display: (flex|inline-flex)

    case 6444:
      switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, (0,stylis__WEBPACK_IMPORTED_MODULE_2__.strlen)(value) - 3 - (~(0,stylis__WEBPACK_IMPORTED_MODULE_2__.indexof)(value, '!important') && 10))) {
        // stic(k)y
        case 107:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, ':', ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT) + value;
        // (inline-)?fl(e)x

        case 101:
          return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + '$2$3' + '$1' + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + '$2box$3') + value;
      }

      break;
    // writing-mode

    case 5936:
      switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.charat)(value, length + 11)) {
        // vertical-l(r)
        case 114:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb') + value;
        // vertical-r(l)

        case 108:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value;
        // horizontal(-)tb

        case 45:
          return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /[svh]\w+-[tblr]{2}/, 'lr') + value;
      }

      return stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + value + stylis__WEBPACK_IMPORTED_MODULE_1__.MS + value + value;
  }

  return value;
}

var prefixer = function prefixer(element, index, children, callback) {
  if (element.length > -1) if (!element["return"]) switch (element.type) {
    case stylis__WEBPACK_IMPORTED_MODULE_1__.DECLARATION:
      element["return"] = prefix(element.value, element.length);
      break;

    case stylis__WEBPACK_IMPORTED_MODULE_1__.KEYFRAMES:
      return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
        value: (0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(element.value, '@', '@' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT)
      })], callback);

    case stylis__WEBPACK_IMPORTED_MODULE_1__.RULESET:
      if (element.length) return (0,stylis__WEBPACK_IMPORTED_MODULE_2__.combine)(element.props, function (value) {
        switch ((0,stylis__WEBPACK_IMPORTED_MODULE_2__.match)(value, /(::plac\w+|:read-\w+)/)) {
          // :read-(only|write)
          case ':read-only':
          case ':read-write':
            return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(read-\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + '$1')]
            })], callback);
          // :placeholder

          case '::placeholder':
            return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)([(0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.WEBKIT + 'input-$1')]
            }), (0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, ':' + stylis__WEBPACK_IMPORTED_MODULE_1__.MOZ + '$1')]
            }), (0,stylis__WEBPACK_IMPORTED_MODULE_4__.copy)(element, {
              props: [(0,stylis__WEBPACK_IMPORTED_MODULE_2__.replace)(value, /:(plac\w+)/, stylis__WEBPACK_IMPORTED_MODULE_1__.MS + 'input-$1')]
            })], callback);
        }

        return '';
      });
  }
};

var defaultStylisPlugins = [prefixer];
var getSourceMap;

{
  var sourceMapPattern = /\/\*#\ssourceMappingURL=data:application\/json;\S+\s+\*\//g;

  getSourceMap = function getSourceMap(styles) {
    var matches = styles.match(sourceMapPattern);
    if (!matches) return;
    return matches[matches.length - 1];
  };
}

var createCache = function createCache(options) {
  var key = options.key;

  if (!key) {
    throw new Error("You have to configure `key` for your cache. Please make sure it's unique (and not equal to 'css') as it's used for linking styles to your cache.\n" + "If multiple caches share the same key they might \"fight\" for each other's style elements.");
  }

  if (key === 'css') {
    var ssrStyles = document.querySelectorAll("style[data-emotion]:not([data-s])"); // get SSRed styles out of the way of React's hydration
    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)
    // note this very very intentionally targets all style elements regardless of the key to ensure
    // that creating a cache works inside of render of a React component

    Array.prototype.forEach.call(ssrStyles, function (node) {
      // we want to only move elements which have a space in the data-emotion attribute value
      // because that indicates that it is an Emotion 11 server-side rendered style elements
      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector
      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)
      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles
      // will not result in the Emotion 10 styles being destroyed
      var dataEmotionAttribute = node.getAttribute('data-emotion');

      if (dataEmotionAttribute.indexOf(' ') === -1) {
        return;
      }

      document.head.appendChild(node);
      node.setAttribute('data-s', '');
    });
  }

  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;

  {
    if (/[^a-z-]/.test(key)) {
      throw new Error("Emotion key must only contain lower case alphabetical characters and - but \"" + key + "\" was passed");
    }
  }

  var inserted = {};
  var container;
  var nodesToHydrate = [];

  {
    container = options.container || document.head;
    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which
    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements
    document.querySelectorAll("style[data-emotion^=\"" + key + " \"]"), function (node) {
      var attrib = node.getAttribute("data-emotion").split(' ');

      for (var i = 1; i < attrib.length; i++) {
        inserted[attrib[i]] = true;
      }

      nodesToHydrate.push(node);
    });
  }

  var _insert;

  var omnipresentPlugins = [compat, removeLabel];

  {
    omnipresentPlugins.push(createUnsafeSelectorsAlarm({
      get compat() {
        return cache.compat;
      }

    }), incorrectImportAlarm);
  }

  {
    var currentSheet;
    var finalizingPlugins = [stylis__WEBPACK_IMPORTED_MODULE_5__.stringify, function (element) {
      if (!element.root) {
        if (element["return"]) {
          currentSheet.insert(element["return"]);
        } else if (element.value && element.type !== stylis__WEBPACK_IMPORTED_MODULE_1__.COMMENT) {
          // insert empty rule in non-production environments
          // so @emotion/jest can grab `key` from the (JS)DOM for caches without any rules inserted yet
          currentSheet.insert(element.value + "{}");
        }
      }
    } ];
    var serializer = (0,stylis__WEBPACK_IMPORTED_MODULE_6__.middleware)(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));

    var stylis = function stylis(styles) {
      return (0,stylis__WEBPACK_IMPORTED_MODULE_5__.serialize)((0,stylis__WEBPACK_IMPORTED_MODULE_3__.compile)(styles), serializer);
    };

    _insert = function insert(selector, serialized, sheet, shouldCache) {
      currentSheet = sheet;

      if (getSourceMap) {
        var sourceMap = getSourceMap(serialized.styles);

        if (sourceMap) {
          currentSheet = {
            insert: function insert(rule) {
              sheet.insert(rule + sourceMap);
            }
          };
        }
      }

      stylis(selector ? selector + "{" + serialized.styles + "}" : serialized.styles);

      if (shouldCache) {
        cache.inserted[serialized.name] = true;
      }
    };
  }

  var cache = {
    key: key,
    sheet: new _emotion_sheet__WEBPACK_IMPORTED_MODULE_0__.StyleSheet({
      key: key,
      container: container,
      nonce: options.nonce,
      speedy: options.speedy,
      prepend: options.prepend,
      insertionPoint: options.insertionPoint
    }),
    nonce: options.nonce,
    inserted: inserted,
    registered: {},
    insert: _insert
  };
  cache.sheet.hydrate(nodesToHydrate);
  return cache;
};




/***/ }),

/***/ "./node_modules/@emotion/hash/dist/emotion-hash.esm.js":
/*!*************************************************************!*\
  !*** ./node_modules/@emotion/hash/dist/emotion-hash.esm.js ***!
  \*************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ murmur2; }
/* harmony export */ });
/* eslint-disable */
// Inspired by https://github.com/garycourt/murmurhash-js
// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86
function murmur2(str) {
  // 'm' and 'r' are mixing constants generated offline.
  // They're not really 'magic', they just happen to work well.
  // const m = 0x5bd1e995;
  // const r = 24;
  // Initialize the hash
  var h = 0; // Mix 4 bytes at a time into the hash

  var k,
      i = 0,
      len = str.length;

  for (; len >= 4; ++i, len -= 4) {
    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
    k =
    /* Math.imul(k, m): */
    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);
    k ^=
    /* k >>> r: */
    k >>> 24;
    h =
    /* Math.imul(k, m): */
    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^
    /* Math.imul(h, m): */
    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  } // Handle the last few bytes of the input array


  switch (len) {
    case 3:
      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;

    case 2:
      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;

    case 1:
      h ^= str.charCodeAt(i) & 0xff;
      h =
      /* Math.imul(h, m): */
      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  } // Do a few final mixes of the hash to ensure the last few
  // bytes are well-incorporated.


  h ^= h >>> 13;
  h =
  /* Math.imul(h, m): */
  (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);
  return ((h ^ h >>> 15) >>> 0).toString(36);
}




/***/ }),

/***/ "./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js":
/*!*******************************************************************************!*\
  !*** ./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js ***!
  \*******************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ isPropValid; }
/* harmony export */ });
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/memoize */ "./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");


// eslint-disable-next-line no-undef
var reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23

var isPropValid = /* #__PURE__ */(0,_emotion_memoize__WEBPACK_IMPORTED_MODULE_0__["default"])(function (prop) {
  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111
  /* o */
  && prop.charCodeAt(1) === 110
  /* n */
  && prop.charCodeAt(2) < 91;
}
/* Z+1 */
);




/***/ }),

/***/ "./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js ***!
  \*******************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ memoize; }
/* harmony export */ });
function memoize(fn) {
  var cache = Object.create(null);
  return function (arg) {
    if (cache[arg] === undefined) cache[arg] = fn(arg);
    return cache[arg];
  };
}




/***/ }),

/***/ "./node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js":
/*!*****************************************************************************************************************!*\
  !*** ./node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js ***!
  \*****************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ hoistNonReactStatics; }
/* harmony export */ });
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! hoist-non-react-statics */ "./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0__);


// this file isolates this package that is not tree-shakeable
// and if this module doesn't actually contain any logic of its own
// then Rollup just use 'hoist-non-react-statics' directly in other chunks

var hoistNonReactStatics = (function (targetComponent, sourceComponent) {
  return hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_0___default()(targetComponent, sourceComponent);
});




/***/ }),

/***/ "./node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js":
/*!**********************************************************************************************!*\
  !*** ./node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js ***!
  \**********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   C: function() { return /* binding */ CacheProvider; },
/* harmony export */   E: function() { return /* binding */ Emotion$1; },
/* harmony export */   T: function() { return /* binding */ ThemeContext; },
/* harmony export */   _: function() { return /* binding */ __unsafe_useEmotionCache; },
/* harmony export */   a: function() { return /* binding */ ThemeProvider; },
/* harmony export */   b: function() { return /* binding */ withTheme; },
/* harmony export */   c: function() { return /* binding */ createEmotionProps; },
/* harmony export */   h: function() { return /* binding */ hasOwn; },
/* harmony export */   u: function() { return /* binding */ useTheme; },
/* harmony export */   w: function() { return /* binding */ withEmotionCache; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/cache */ "./node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @babel/runtime/helpers/esm/extends */ "./node_modules/@emotion/react/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/weak-memoize */ "./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var _isolated_hnrs_dist_emotion_react_isolated_hnrs_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js */ "./node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/utils */ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/serialize */ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");










var EmotionCacheContext = /* #__PURE__ */react__WEBPACK_IMPORTED_MODULE_0__.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case
// because this module is primarily intended for the browser and node
// but it's also required in react native and similar environments sometimes
// and we could have a special build just for that
// but this is much easier and the native packages
// might use a different theme context in the future anyway
typeof HTMLElement !== 'undefined' ? /* #__PURE__ */(0,_emotion_cache__WEBPACK_IMPORTED_MODULE_1__["default"])({
  key: 'css'
}) : null);

{
  EmotionCacheContext.displayName = 'EmotionCacheContext';
}

var CacheProvider = EmotionCacheContext.Provider;
var __unsafe_useEmotionCache = function useEmotionCache() {
  return (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(EmotionCacheContext);
};

var withEmotionCache = function withEmotionCache(func) {
  return /*#__PURE__*/(0,react__WEBPACK_IMPORTED_MODULE_0__.forwardRef)(function (props, ref) {
    // the cache will never be null in the browser
    var cache = (0,react__WEBPACK_IMPORTED_MODULE_0__.useContext)(EmotionCacheContext);
    return func(props, cache, ref);
  });
};

var ThemeContext = /* #__PURE__ */react__WEBPACK_IMPORTED_MODULE_0__.createContext({});

{
  ThemeContext.displayName = 'EmotionThemeContext';
}

var useTheme = function useTheme() {
  return react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);
};

var getTheme = function getTheme(outerTheme, theme) {
  if (typeof theme === 'function') {
    var mergedTheme = theme(outerTheme);

    if ((mergedTheme == null || typeof mergedTheme !== 'object' || Array.isArray(mergedTheme))) {
      throw new Error('[ThemeProvider] Please return an object from your theme function, i.e. theme={() => ({})}!');
    }

    return mergedTheme;
  }

  if ((theme == null || typeof theme !== 'object' || Array.isArray(theme))) {
    throw new Error('[ThemeProvider] Please make your theme prop a plain object');
  }

  return (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__["default"])({}, outerTheme, theme);
};

var createCacheWithTheme = /* #__PURE__ */(0,_emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__["default"])(function (outerTheme) {
  return (0,_emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_3__["default"])(function (theme) {
    return getTheme(outerTheme, theme);
  });
});
var ThemeProvider = function ThemeProvider(props) {
  var theme = react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);

  if (props.theme !== theme) {
    theme = createCacheWithTheme(theme)(props.theme);
  }

  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(ThemeContext.Provider, {
    value: theme
  }, props.children);
};
function withTheme(Component) {
  var componentName = Component.displayName || Component.name || 'Component';
  var WithTheme = /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(function render(props, ref) {
    var theme = react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext);
    return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Component, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_2__["default"])({
      theme: theme,
      ref: ref
    }, props));
  });
  WithTheme.displayName = "WithTheme(" + componentName + ")";
  return (0,_isolated_hnrs_dist_emotion_react_isolated_hnrs_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_4__["default"])(WithTheme, Component);
}

var hasOwn = {}.hasOwnProperty;

var getLastPart = function getLastPart(functionName) {
  // The match may be something like 'Object.createEmotionProps' or
  // 'Loader.prototype.render'
  var parts = functionName.split('.');
  return parts[parts.length - 1];
};

var getFunctionNameFromStackTraceLine = function getFunctionNameFromStackTraceLine(line) {
  // V8
  var match = /^\s+at\s+([A-Za-z0-9$.]+)\s/.exec(line);
  if (match) return getLastPart(match[1]); // Safari / Firefox

  match = /^([A-Za-z0-9$.]+)@/.exec(line);
  if (match) return getLastPart(match[1]);
  return undefined;
};

var internalReactFunctionNames = /* #__PURE__ */new Set(['renderWithHooks', 'processChild', 'finishClassComponent', 'renderToString']); // These identifiers come from error stacks, so they have to be valid JS
// identifiers, thus we only need to replace what is a valid character for JS,
// but not for CSS.

var sanitizeIdentifier = function sanitizeIdentifier(identifier) {
  return identifier.replace(/\$/g, '-');
};

var getLabelFromStackTrace = function getLabelFromStackTrace(stackTrace) {
  if (!stackTrace) return undefined;
  var lines = stackTrace.split('\n');

  for (var i = 0; i < lines.length; i++) {
    var functionName = getFunctionNameFromStackTraceLine(lines[i]); // The first line of V8 stack traces is just "Error"

    if (!functionName) continue; // If we reach one of these, we have gone too far and should quit

    if (internalReactFunctionNames.has(functionName)) break; // The component name is the first function in the stack that starts with an
    // uppercase letter

    if (/^[A-Z]/.test(functionName)) return sanitizeIdentifier(functionName);
  }

  return undefined;
};

var typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';
var labelPropName = '__EMOTION_LABEL_PLEASE_DO_NOT_USE__';
var createEmotionProps = function createEmotionProps(type, props) {
  if (typeof props.css === 'string' && // check if there is a css declaration
  props.css.indexOf(':') !== -1) {
    throw new Error("Strings are not allowed as css prop values, please wrap it in a css template literal from '@emotion/react' like this: css`" + props.css + "`");
  }

  var newProps = {};

  for (var _key in props) {
    if (hasOwn.call(props, _key)) {
      newProps[_key] = props[_key];
    }
  }

  newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:
  // - It causes hydration warnings when using Safari and SSR
  // - It can degrade performance if there are a huge number of elements
  //
  // Even if the flag is set, we still don't compute the label if it has already
  // been determined by the Babel plugin.

  if (typeof globalThis !== 'undefined' && !!globalThis.EMOTION_RUNTIME_AUTO_LABEL && !!props.css && (typeof props.css !== 'object' || !('name' in props.css) || typeof props.css.name !== 'string' || props.css.name.indexOf('-') === -1)) {
    var label = getLabelFromStackTrace(new Error().stack);
    if (label) newProps[labelPropName] = label;
  }

  return newProps;
};

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.registerStyles)(cache, serialized, isStringTag);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_7__.useInsertionEffectAlwaysWithSyncFallback)(function () {
    return (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.insertStyles)(cache, serialized, isStringTag);
  });

  return null;
};

var Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {
  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works
  // not passing the registered cache to serializeStyles because it would
  // make certain babel optimisations not possible

  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {
    cssProp = cache.registered[cssProp];
  }

  var WrappedComponent = props[typePropName];
  var registeredStyles = [cssProp];
  var className = '';

  if (typeof props.className === 'string') {
    className = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_5__.getRegisteredStyles)(cache.registered, registeredStyles, props.className);
  } else if (props.className != null) {
    className = props.className + " ";
  }

  var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_6__.serializeStyles)(registeredStyles, undefined, react__WEBPACK_IMPORTED_MODULE_0__.useContext(ThemeContext));

  if (serialized.name.indexOf('-') === -1) {
    var labelFromStack = props[labelPropName];

    if (labelFromStack) {
      serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_6__.serializeStyles)([serialized, 'label:' + labelFromStack + ';']);
    }
  }

  className += cache.key + "-" + serialized.name;
  var newProps = {};

  for (var _key2 in props) {
    if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && (_key2 !== labelPropName)) {
      newProps[_key2] = props[_key2];
    }
  }

  newProps.className = className;

  if (ref) {
    newProps.ref = ref;
  }

  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(react__WEBPACK_IMPORTED_MODULE_0__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(Insertion, {
    cache: cache,
    serialized: serialized,
    isStringTag: typeof WrappedComponent === 'string'
  }), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement(WrappedComponent, newProps));
});

{
  Emotion.displayName = 'EmotionCssPropInternal';
}

var Emotion$1 = Emotion;




/***/ }),

/***/ "./node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js":
/*!***********************************************************************************!*\
  !*** ./node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CacheProvider: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.C; },
/* harmony export */   ClassNames: function() { return /* binding */ ClassNames; },
/* harmony export */   Global: function() { return /* binding */ Global; },
/* harmony export */   ThemeContext: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T; },
/* harmony export */   ThemeProvider: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.a; },
/* harmony export */   __unsafe_useEmotionCache: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__._; },
/* harmony export */   createElement: function() { return /* binding */ jsx; },
/* harmony export */   css: function() { return /* binding */ css; },
/* harmony export */   jsx: function() { return /* binding */ jsx; },
/* harmony export */   keyframes: function() { return /* binding */ keyframes; },
/* harmony export */   useTheme: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.u; },
/* harmony export */   withEmotionCache: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w; },
/* harmony export */   withTheme: function() { return /* reexport safe */ _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.b; }
/* harmony export */ });
/* harmony import */ var _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./emotion-element-489459f2.browser.development.esm.js */ "./node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/utils */ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/serialize */ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/cache */ "./node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "./node_modules/@emotion/react/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/weak-memoize */ "./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! hoist-non-react-statics */ "./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_8__);












var isDevelopment = true;

var pkg = {
	name: "@emotion/react",
	version: "11.14.0",
	main: "dist/emotion-react.cjs.js",
	module: "dist/emotion-react.esm.js",
	types: "dist/emotion-react.cjs.d.ts",
	exports: {
		".": {
			types: {
				"import": "./dist/emotion-react.cjs.mjs",
				"default": "./dist/emotion-react.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				worker: {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./dist/emotion-react.development.edge-light.esm.js",
					"import": "./dist/emotion-react.development.edge-light.cjs.mjs",
					"default": "./dist/emotion-react.development.edge-light.cjs.js"
				},
				browser: {
					module: "./dist/emotion-react.browser.development.esm.js",
					"import": "./dist/emotion-react.browser.development.cjs.mjs",
					"default": "./dist/emotion-react.browser.development.cjs.js"
				},
				module: "./dist/emotion-react.development.esm.js",
				"import": "./dist/emotion-react.development.cjs.mjs",
				"default": "./dist/emotion-react.development.cjs.js"
			},
			"edge-light": {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			worker: {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			workerd: {
				module: "./dist/emotion-react.edge-light.esm.js",
				"import": "./dist/emotion-react.edge-light.cjs.mjs",
				"default": "./dist/emotion-react.edge-light.cjs.js"
			},
			browser: {
				module: "./dist/emotion-react.browser.esm.js",
				"import": "./dist/emotion-react.browser.cjs.mjs",
				"default": "./dist/emotion-react.browser.cjs.js"
			},
			module: "./dist/emotion-react.esm.js",
			"import": "./dist/emotion-react.cjs.mjs",
			"default": "./dist/emotion-react.cjs.js"
		},
		"./jsx-runtime": {
			types: {
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				worker: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.edge-light.cjs.js"
				},
				browser: {
					module: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js",
					"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.cjs.mjs",
					"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.cjs.js"
				},
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.development.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.development.cjs.js"
			},
			"edge-light": {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			worker: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			workerd: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.edge-light.cjs.js"
			},
			browser: {
				module: "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.esm.js",
				"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.cjs.mjs",
				"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.browser.cjs.js"
			},
			module: "./jsx-runtime/dist/emotion-react-jsx-runtime.esm.js",
			"import": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.mjs",
			"default": "./jsx-runtime/dist/emotion-react-jsx-runtime.cjs.js"
		},
		"./_isolated-hnrs": {
			types: {
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				worker: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.edge-light.cjs.js"
				},
				browser: {
					module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.esm.js",
					"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.cjs.mjs",
					"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.development.cjs.js"
				},
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.development.cjs.js"
			},
			"edge-light": {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			worker: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			workerd: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.edge-light.cjs.js"
			},
			browser: {
				module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js",
				"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.cjs.mjs",
				"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.cjs.js"
			},
			module: "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.esm.js",
			"import": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.mjs",
			"default": "./_isolated-hnrs/dist/emotion-react-_isolated-hnrs.cjs.js"
		},
		"./jsx-dev-runtime": {
			types: {
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
			},
			development: {
				"edge-light": {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				worker: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				workerd: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.edge-light.cjs.js"
				},
				browser: {
					module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.esm.js",
					"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.cjs.mjs",
					"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.development.cjs.js"
				},
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.development.cjs.js"
			},
			"edge-light": {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			worker: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			workerd: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.edge-light.cjs.js"
			},
			browser: {
				module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.esm.js",
				"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.cjs.mjs",
				"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.browser.cjs.js"
			},
			module: "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.esm.js",
			"import": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.mjs",
			"default": "./jsx-dev-runtime/dist/emotion-react-jsx-dev-runtime.cjs.js"
		},
		"./package.json": "./package.json",
		"./types/css-prop": "./types/css-prop.d.ts",
		"./macro": {
			types: {
				"import": "./macro.d.mts",
				"default": "./macro.d.ts"
			},
			"default": "./macro.js"
		}
	},
	imports: {
		"#is-development": {
			development: "./src/conditions/true.ts",
			"default": "./src/conditions/false.ts"
		},
		"#is-browser": {
			"edge-light": "./src/conditions/false.ts",
			workerd: "./src/conditions/false.ts",
			worker: "./src/conditions/false.ts",
			browser: "./src/conditions/true.ts",
			"default": "./src/conditions/is-browser.ts"
		}
	},
	files: [
		"src",
		"dist",
		"jsx-runtime",
		"jsx-dev-runtime",
		"_isolated-hnrs",
		"types/css-prop.d.ts",
		"macro.*"
	],
	sideEffects: false,
	author: "Emotion Contributors",
	license: "MIT",
	scripts: {
		"test:typescript": "dtslint types"
	},
	dependencies: {
		"@babel/runtime": "^7.18.3",
		"@emotion/babel-plugin": "^11.13.5",
		"@emotion/cache": "^11.14.0",
		"@emotion/serialize": "^1.3.3",
		"@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
		"@emotion/utils": "^1.4.2",
		"@emotion/weak-memoize": "^0.4.0",
		"hoist-non-react-statics": "^3.3.1"
	},
	peerDependencies: {
		react: ">=16.8.0"
	},
	peerDependenciesMeta: {
		"@types/react": {
			optional: true
		}
	},
	devDependencies: {
		"@definitelytyped/dtslint": "0.0.112",
		"@emotion/css": "11.13.5",
		"@emotion/css-prettifier": "1.2.0",
		"@emotion/server": "11.11.0",
		"@emotion/styled": "11.14.0",
		"@types/hoist-non-react-statics": "^3.3.5",
		"html-tag-names": "^1.1.2",
		react: "16.14.0",
		"svg-tag-names": "^1.1.1",
		typescript: "^5.4.5"
	},
	repository: "https://github.com/emotion-js/emotion/tree/main/packages/react",
	publishConfig: {
		access: "public"
	},
	"umd:main": "dist/emotion-react.umd.min.js",
	preconstruct: {
		entrypoints: [
			"./index.ts",
			"./jsx-runtime.ts",
			"./jsx-dev-runtime.ts",
			"./_isolated-hnrs.ts"
		],
		umdName: "emotionReact",
		exports: {
			extra: {
				"./types/css-prop": "./types/css-prop.d.ts",
				"./macro": {
					types: {
						"import": "./macro.d.mts",
						"default": "./macro.d.ts"
					},
					"default": "./macro.js"
				}
			}
		}
	}
};

var jsx = function jsx(type, props) {
  // eslint-disable-next-line prefer-rest-params
  var args = arguments;

  if (props == null || !_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.h.call(props, 'css')) {
    return react__WEBPACK_IMPORTED_MODULE_1__.createElement.apply(undefined, args);
  }

  var argsLength = args.length;
  var createElementArgArray = new Array(argsLength);
  createElementArgArray[0] = _emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.E;
  createElementArgArray[1] = (0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.c)(type, props);

  for (var i = 2; i < argsLength; i++) {
    createElementArgArray[i] = args[i];
  }

  return react__WEBPACK_IMPORTED_MODULE_1__.createElement.apply(null, createElementArgArray);
};

(function (_jsx) {
  var JSX;

  (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));
})(jsx || (jsx = {}));

var warnedAboutCssPropForGlobal = false; // maintain place over rerenders.
// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild
// initial client-side render from SSR, use place of hydrating tag

var Global = /* #__PURE__ */(0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w)(function (props, cache) {
  if (!warnedAboutCssPropForGlobal && ( // check for className as well since the user is
  // probably using the custom createElement which
  // means it will be turned into a className prop
  // I don't really want to add it to the type since it shouldn't be used
  'className' in props && props.className || 'css' in props && props.css)) {
    console.error("It looks like you're using the css prop on Global, did you mean to use the styles prop instead?");
    warnedAboutCssPropForGlobal = true;
  }

  var styles = props.styles;
  var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)([styles], undefined, react__WEBPACK_IMPORTED_MODULE_1__.useContext(_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T));
  // but it is based on a constant that will never change at runtime
  // it's effectively like having two implementations and switching them out
  // so it's not actually breaking anything


  var sheetRef = react__WEBPACK_IMPORTED_MODULE_1__.useRef();
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectWithLayoutFallback)(function () {
    var key = cache.key + "-global"; // use case of https://github.com/emotion-js/emotion/issues/2675

    var sheet = new cache.sheet.constructor({
      key: key,
      nonce: cache.sheet.nonce,
      container: cache.sheet.container,
      speedy: cache.sheet.isSpeedy
    });
    var rehydrating = false;
    var node = document.querySelector("style[data-emotion=\"" + key + " " + serialized.name + "\"]");

    if (cache.sheet.tags.length) {
      sheet.before = cache.sheet.tags[0];
    }

    if (node !== null) {
      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s

      node.setAttribute('data-emotion', key);
      sheet.hydrate([node]);
    }

    sheetRef.current = [sheet, rehydrating];
    return function () {
      sheet.flush();
    };
  }, [cache]);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectWithLayoutFallback)(function () {
    var sheetRefCurrent = sheetRef.current;
    var sheet = sheetRefCurrent[0],
        rehydrating = sheetRefCurrent[1];

    if (rehydrating) {
      sheetRefCurrent[1] = false;
      return;
    }

    if (serialized.next !== undefined) {
      // insert keyframes
      (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.insertStyles)(cache, serialized.next, true);
    }

    if (sheet.tags.length) {
      // if this doesn't exist then it will be null so the style element will be appended
      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;
      sheet.before = element;
      sheet.flush();
    }

    cache.insert("", serialized, sheet, false);
  }, [cache, serialized.name]);
  return null;
});

{
  Global.displayName = 'EmotionGlobal';
}

function css() {
  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
    args[_key] = arguments[_key];
  }

  return (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)(args);
}

function keyframes() {
  var insertable = css.apply(void 0, arguments);
  var name = "animation-" + insertable.name;
  return {
    name: name,
    styles: "@keyframes " + name + "{" + insertable.styles + "}",
    anim: 1,
    toString: function toString() {
      return "_EMO_" + this.name + "_" + this.styles + "_EMO_";
    }
  };
}

var classnames = function classnames(args) {
  var len = args.length;
  var i = 0;
  var cls = '';

  for (; i < len; i++) {
    var arg = args[i];
    if (arg == null) continue;
    var toAdd = void 0;

    switch (typeof arg) {
      case 'boolean':
        break;

      case 'object':
        {
          if (Array.isArray(arg)) {
            toAdd = classnames(arg);
          } else {
            if (arg.styles !== undefined && arg.name !== undefined) {
              console.error('You have passed styles created with `css` from `@emotion/react` package to the `cx`.\n' + '`cx` is meant to compose class names (strings) so you should convert those styles to a class name by passing them to the `css` received from <ClassNames/> component.');
            }

            toAdd = '';

            for (var k in arg) {
              if (arg[k] && k) {
                toAdd && (toAdd += ' ');
                toAdd += k;
              }
            }
          }

          break;
        }

      default:
        {
          toAdd = arg;
        }
    }

    if (toAdd) {
      cls && (cls += ' ');
      cls += toAdd;
    }
  }

  return cls;
};

function merge(registered, css, className) {
  var registeredStyles = [];
  var rawClassName = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.getRegisteredStyles)(registered, registeredStyles, className);

  if (registeredStyles.length < 2) {
    return className;
  }

  return rawClassName + css(registeredStyles);
}

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serializedArr = _ref.serializedArr;
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectAlwaysWithSyncFallback)(function () {

    for (var i = 0; i < serializedArr.length; i++) {
      (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.insertStyles)(cache, serializedArr[i], false);
    }
  });

  return null;
};

var ClassNames = /* #__PURE__ */(0,_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.w)(function (props, cache) {
  var hasRendered = false;
  var serializedArr = [];

  var css = function css() {
    if (hasRendered && isDevelopment) {
      throw new Error('css can only be used during render');
    }

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_4__.serializeStyles)(args, cache.registered);
    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`

    (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_2__.registerStyles)(cache, serialized, false);
    return cache.key + "-" + serialized.name;
  };

  var cx = function cx() {
    if (hasRendered && isDevelopment) {
      throw new Error('cx can only be used during render');
    }

    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    return merge(cache.registered, css, classnames(args));
  };

  var content = {
    css: css,
    cx: cx,
    theme: react__WEBPACK_IMPORTED_MODULE_1__.useContext(_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__.T)
  };
  var ele = props.children(content);
  hasRendered = true;
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(react__WEBPACK_IMPORTED_MODULE_1__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_1__.createElement(Insertion, {
    cache: cache,
    serializedArr: serializedArr
  }), ele);
});

{
  ClassNames.displayName = 'EmotionClassNames';
}

{
  var isBrowser = typeof document !== 'undefined'; // #1727, #2905 for some reason Jest and Vitest evaluate modules twice if some consuming module gets mocked

  var isTestEnv = typeof jest !== 'undefined' || typeof vi !== 'undefined';

  if (isBrowser && !isTestEnv) {
    // globalThis has wide browser support - https://caniuse.com/?search=globalThis, Node.js 12 and later
    var globalContext = typeof globalThis !== 'undefined' ? globalThis // eslint-disable-line no-undef
    : isBrowser ? window : __webpack_require__.g;
    var globalKey = "__EMOTION_REACT_" + pkg.version.split('.')[0] + "__";

    if (globalContext[globalKey]) {
      console.warn('You are loading @emotion/react when it is already loaded. Running ' + 'multiple instances may cause problems. This can happen if multiple ' + 'versions are used, or if multiple builds of the same version are ' + 'used.');
    }

    globalContext[globalKey] = true;
  }
}




/***/ }),

/***/ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js":
/*!***********************************************************************************************************!*\
  !*** ./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js ***!
  \***********************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Fragment: function() { return /* binding */ Fragment; },
/* harmony export */   jsx: function() { return /* binding */ jsx; },
/* harmony export */   jsxs: function() { return /* binding */ jsxs; }
/* harmony export */ });
/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react/jsx-runtime */ "react/jsx-runtime");
/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../dist/emotion-element-489459f2.browser.development.esm.js */ "./node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _emotion_cache__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/cache */ "./node_modules/@emotion/cache/dist/emotion-cache.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "./node_modules/@emotion/react/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_weak_memoize__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @emotion/weak-memoize */ "./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! hoist-non-react-statics */ "./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
/* harmony import */ var hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(hoist_non_react_statics__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @emotion/utils */ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @emotion/serialize */ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");












var Fragment = react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment;
var jsx = function jsx(type, props, key) {
  if (!_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.h.call(props, 'css')) {
    return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx(type, props, key);
  }

  return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx(_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.E, (0,_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.c)(type, props), key);
};
var jsxs = function jsxs(type, props, key) {
  if (!_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.h.call(props, 'css')) {
    return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs(type, props, key);
  }

  return react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs(_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.E, (0,_dist_emotion_element_489459f2_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_1__.c)(type, props), key);
};




/***/ }),

/***/ "./node_modules/@emotion/react/node_modules/@babel/runtime/helpers/esm/extends.js":
/*!****************************************************************************************!*\
  !*** ./node_modules/@emotion/react/node_modules/@babel/runtime/helpers/esm/extends.js ***!
  \****************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ _extends; }
/* harmony export */ });
function _extends() {
  return _extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e < arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
    }
    return n;
  }, _extends.apply(null, arguments);
}


/***/ }),

/***/ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js":
/*!***********************************************************************************!*\
  !*** ./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js ***!
  \***********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   serializeStyles: function() { return /* binding */ serializeStyles; }
/* harmony export */ });
/* harmony import */ var _emotion_hash__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/hash */ "./node_modules/@emotion/hash/dist/emotion-hash.esm.js");
/* harmony import */ var _emotion_unitless__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/unitless */ "./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js");
/* harmony import */ var _emotion_memoize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/memoize */ "./node_modules/@emotion/memoize/dist/emotion-memoize.esm.js");




var isDevelopment = true;

var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";
var UNDEFINED_AS_OBJECT_KEY_ERROR = "You have passed in falsy value as style object's key (can happen when in example you pass unexported component as computed key).";
var hyphenateRegex = /[A-Z]|^ms/g;
var animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;

var isCustomProperty = function isCustomProperty(property) {
  return property.charCodeAt(1) === 45;
};

var isProcessableValue = function isProcessableValue(value) {
  return value != null && typeof value !== 'boolean';
};

var processStyleName = /* #__PURE__ */(0,_emotion_memoize__WEBPACK_IMPORTED_MODULE_2__["default"])(function (styleName) {
  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();
});

var processStyleValue = function processStyleValue(key, value) {
  switch (key) {
    case 'animation':
    case 'animationName':
      {
        if (typeof value === 'string') {
          return value.replace(animationRegex, function (match, p1, p2) {
            cursor = {
              name: p1,
              styles: p2,
              next: cursor
            };
            return p1;
          });
        }
      }
  }

  if (_emotion_unitless__WEBPACK_IMPORTED_MODULE_1__["default"][key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {
    return value + 'px';
  }

  return value;
};

{
  var contentValuePattern = /(var|attr|counters?|url|element|(((repeating-)?(linear|radial))|conic)-gradient)\(|(no-)?(open|close)-quote/;
  var contentValues = ['normal', 'none', 'initial', 'inherit', 'unset'];
  var oldProcessStyleValue = processStyleValue;
  var msPattern = /^-ms-/;
  var hyphenPattern = /-(.)/g;
  var hyphenatedCache = {};

  processStyleValue = function processStyleValue(key, value) {
    if (key === 'content') {
      if (typeof value !== 'string' || contentValues.indexOf(value) === -1 && !contentValuePattern.test(value) && (value.charAt(0) !== value.charAt(value.length - 1) || value.charAt(0) !== '"' && value.charAt(0) !== "'")) {
        throw new Error("You seem to be using a value for 'content' without quotes, try replacing it with `content: '\"" + value + "\"'`");
      }
    }

    var processed = oldProcessStyleValue(key, value);

    if (processed !== '' && !isCustomProperty(key) && key.indexOf('-') !== -1 && hyphenatedCache[key] === undefined) {
      hyphenatedCache[key] = true;
      console.error("Using kebab-case for css properties in objects is not supported. Did you mean " + key.replace(msPattern, 'ms-').replace(hyphenPattern, function (str, _char) {
        return _char.toUpperCase();
      }) + "?");
    }

    return processed;
  };
}

var noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';

function handleInterpolation(mergedProps, registered, interpolation) {
  if (interpolation == null) {
    return '';
  }

  var componentSelector = interpolation;

  if (componentSelector.__emotion_styles !== undefined) {
    if (String(componentSelector) === 'NO_COMPONENT_SELECTOR') {
      throw new Error(noComponentSelectorMessage);
    }

    return componentSelector;
  }

  switch (typeof interpolation) {
    case 'boolean':
      {
        return '';
      }

    case 'object':
      {
        var keyframes = interpolation;

        if (keyframes.anim === 1) {
          cursor = {
            name: keyframes.name,
            styles: keyframes.styles,
            next: cursor
          };
          return keyframes.name;
        }

        var serializedStyles = interpolation;

        if (serializedStyles.styles !== undefined) {
          var next = serializedStyles.next;

          if (next !== undefined) {
            // not the most efficient thing ever but this is a pretty rare case
            // and there will be very few iterations of this generally
            while (next !== undefined) {
              cursor = {
                name: next.name,
                styles: next.styles,
                next: cursor
              };
              next = next.next;
            }
          }

          var styles = serializedStyles.styles + ";";
          return styles;
        }

        return createStringFromObject(mergedProps, registered, interpolation);
      }

    case 'function':
      {
        if (mergedProps !== undefined) {
          var previousCursor = cursor;
          var result = interpolation(mergedProps);
          cursor = previousCursor;
          return handleInterpolation(mergedProps, registered, result);
        } else {
          console.error('Functions that are interpolated in css calls will be stringified.\n' + 'If you want to have a css call based on props, create a function that returns a css call like this\n' + 'let dynamicStyle = (props) => css`color: ${props.color}`\n' + 'It can be called directly with props or interpolated in a styled call like this\n' + "let SomeComponent = styled('div')`${dynamicStyle}`");
        }

        break;
      }

    case 'string':
      {
        var matched = [];
        var replaced = interpolation.replace(animationRegex, function (_match, _p1, p2) {
          var fakeVarName = "animation" + matched.length;
          matched.push("const " + fakeVarName + " = keyframes`" + p2.replace(/^@keyframes animation-\w+/, '') + "`");
          return "${" + fakeVarName + "}";
        });

        if (matched.length) {
          console.error("`keyframes` output got interpolated into plain string, please wrap it with `css`.\n\nInstead of doing this:\n\n" + [].concat(matched, ["`" + replaced + "`"]).join('\n') + "\n\nYou should wrap it with `css` like this:\n\ncss`" + replaced + "`");
        }
      }

      break;
  } // finalize string values (regular strings and functions interpolated into css calls)


  var asString = interpolation;

  if (registered == null) {
    return asString;
  }

  var cached = registered[asString];
  return cached !== undefined ? cached : asString;
}

function createStringFromObject(mergedProps, registered, obj) {
  var string = '';

  if (Array.isArray(obj)) {
    for (var i = 0; i < obj.length; i++) {
      string += handleInterpolation(mergedProps, registered, obj[i]) + ";";
    }
  } else {
    for (var key in obj) {
      var value = obj[key];

      if (typeof value !== 'object') {
        var asString = value;

        if (registered != null && registered[asString] !== undefined) {
          string += key + "{" + registered[asString] + "}";
        } else if (isProcessableValue(asString)) {
          string += processStyleName(key) + ":" + processStyleValue(key, asString) + ";";
        }
      } else {
        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {
          throw new Error(noComponentSelectorMessage);
        }

        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {
          for (var _i = 0; _i < value.length; _i++) {
            if (isProcessableValue(value[_i])) {
              string += processStyleName(key) + ":" + processStyleValue(key, value[_i]) + ";";
            }
          }
        } else {
          var interpolated = handleInterpolation(mergedProps, registered, value);

          switch (key) {
            case 'animation':
            case 'animationName':
              {
                string += processStyleName(key) + ":" + interpolated + ";";
                break;
              }

            default:
              {
                if (key === 'undefined') {
                  console.error(UNDEFINED_AS_OBJECT_KEY_ERROR);
                }

                string += key + "{" + interpolated + "}";
              }
          }
        }
      }
    }
  }

  return string;
}

var labelPattern = /label:\s*([^\s;{]+)\s*(;|$)/g; // this is the cursor for keyframes
// keyframes are stored on the SerializedStyles object as a linked list

var cursor;
function serializeStyles(args, registered, mergedProps) {
  if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {
    return args[0];
  }

  var stringMode = true;
  var styles = '';
  cursor = undefined;
  var strings = args[0];

  if (strings == null || strings.raw === undefined) {
    stringMode = false;
    styles += handleInterpolation(mergedProps, registered, strings);
  } else {
    var asTemplateStringsArr = strings;

    if (asTemplateStringsArr[0] === undefined) {
      console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
    }

    styles += asTemplateStringsArr[0];
  } // we start at 1 since we've already handled the first arg


  for (var i = 1; i < args.length; i++) {
    styles += handleInterpolation(mergedProps, registered, args[i]);

    if (stringMode) {
      var templateStringsArr = strings;

      if (templateStringsArr[i] === undefined) {
        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
      }

      styles += templateStringsArr[i];
    }
  } // using a global regex with .exec is stateful so lastIndex has to be reset each time


  labelPattern.lastIndex = 0;
  var identifierName = '';
  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5

  while ((match = labelPattern.exec(styles)) !== null) {
    identifierName += '-' + match[1];
  }

  var name = (0,_emotion_hash__WEBPACK_IMPORTED_MODULE_0__["default"])(styles) + identifierName;

  {
    var devStyles = {
      name: name,
      styles: styles,
      next: cursor,
      toString: function toString() {
        return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop).";
      }
    };
    return devStyles;
  }
}




/***/ }),

/***/ "./node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js":
/*!***************************************************************************!*\
  !*** ./node_modules/@emotion/sheet/dist/emotion-sheet.development.esm.js ***!
  \***************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyleSheet: function() { return /* binding */ StyleSheet; }
/* harmony export */ });
var isDevelopment = true;

/*

Based off glamor's StyleSheet, thanks Sunil ❤️

high performance StyleSheet for css-in-js systems

- uses multiple style tags behind the scenes for millions of rules
- uses `insertRule` for appending in production for *much* faster performance

// usage

import { StyleSheet } from '@emotion/sheet'

let styleSheet = new StyleSheet({ key: '', container: document.head })

styleSheet.insert('#box { border: 1px solid red; }')
- appends a css rule into the stylesheet

styleSheet.flush()
- empties the stylesheet of all its contents

*/

function sheetForTag(tag) {
  if (tag.sheet) {
    return tag.sheet;
  } // this weirdness brought to you by firefox

  /* istanbul ignore next */


  for (var i = 0; i < document.styleSheets.length; i++) {
    if (document.styleSheets[i].ownerNode === tag) {
      return document.styleSheets[i];
    }
  } // this function should always return with a value
  // TS can't understand it though so we make it stop complaining here


  return undefined;
}

function createStyleElement(options) {
  var tag = document.createElement('style');
  tag.setAttribute('data-emotion', options.key);

  if (options.nonce !== undefined) {
    tag.setAttribute('nonce', options.nonce);
  }

  tag.appendChild(document.createTextNode(''));
  tag.setAttribute('data-s', '');
  return tag;
}

var StyleSheet = /*#__PURE__*/function () {
  // Using Node instead of HTMLElement since container may be a ShadowRoot
  function StyleSheet(options) {
    var _this = this;

    this._insertTag = function (tag) {
      var before;

      if (_this.tags.length === 0) {
        if (_this.insertionPoint) {
          before = _this.insertionPoint.nextSibling;
        } else if (_this.prepend) {
          before = _this.container.firstChild;
        } else {
          before = _this.before;
        }
      } else {
        before = _this.tags[_this.tags.length - 1].nextSibling;
      }

      _this.container.insertBefore(tag, before);

      _this.tags.push(tag);
    };

    this.isSpeedy = options.speedy === undefined ? !isDevelopment : options.speedy;
    this.tags = [];
    this.ctr = 0;
    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets

    this.key = options.key;
    this.container = options.container;
    this.prepend = options.prepend;
    this.insertionPoint = options.insertionPoint;
    this.before = null;
  }

  var _proto = StyleSheet.prototype;

  _proto.hydrate = function hydrate(nodes) {
    nodes.forEach(this._insertTag);
  };

  _proto.insert = function insert(rule) {
    // the max length is how many rules we have per style tag, it's 65000 in speedy mode
    // it's 1 in dev because we insert source maps that map a single rule to a location
    // and you can only have one source map per style tag
    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {
      this._insertTag(createStyleElement(this));
    }

    var tag = this.tags[this.tags.length - 1];

    {
      var isImportRule = rule.charCodeAt(0) === 64 && rule.charCodeAt(1) === 105;

      if (isImportRule && this._alreadyInsertedOrderInsensitiveRule) {
        // this would only cause problem in speedy mode
        // but we don't want enabling speedy to affect the observable behavior
        // so we report this error at all times
        console.error("You're attempting to insert the following rule:\n" + rule + '\n\n`@import` rules must be before all other types of rules in a stylesheet but other rules have already been inserted. Please ensure that `@import` rules are before all other rules.');
      }

      this._alreadyInsertedOrderInsensitiveRule = this._alreadyInsertedOrderInsensitiveRule || !isImportRule;
    }

    if (this.isSpeedy) {
      var sheet = sheetForTag(tag);

      try {
        // this is the ultrafast version, works across browsers
        // the big drawback is that the css won't be editable in devtools
        sheet.insertRule(rule, sheet.cssRules.length);
      } catch (e) {
        if (!/:(-moz-placeholder|-moz-focus-inner|-moz-focusring|-ms-input-placeholder|-moz-read-write|-moz-read-only|-ms-clear|-ms-expand|-ms-reveal){/.test(rule)) {
          console.error("There was a problem inserting the following rule: \"" + rule + "\"", e);
        }
      }
    } else {
      tag.appendChild(document.createTextNode(rule));
    }

    this.ctr++;
  };

  _proto.flush = function flush() {
    this.tags.forEach(function (tag) {
      var _tag$parentNode;

      return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);
    });
    this.tags = [];
    this.ctr = 0;

    {
      this._alreadyInsertedOrderInsensitiveRule = false;
    }
  };

  return StyleSheet;
}();




/***/ }),

/***/ "./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js":
/*!***********************************************************************************************!*\
  !*** ./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js ***!
  \***********************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ createStyled; }
/* harmony export */ });
/* harmony import */ var _babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @babel/runtime/helpers/esm/extends */ "./node_modules/@emotion/styled/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/react */ "./node_modules/@emotion/react/dist/emotion-element-489459f2.browser.development.esm.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/serialize */ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/utils */ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/is-prop-valid */ "./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js");








var isDevelopment = true;

var testOmitPropsOnStringTag = _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__["default"];

var testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {
  return key !== 'theme';
};

var getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {
  return typeof tag === 'string' && // 96 is one less than the char code
  // for "a" so this is checking that
  // it's a lowercase character
  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;
};
var composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {
  var shouldForwardProp;

  if (options) {
    var optionsShouldForwardProp = options.shouldForwardProp;
    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {
      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);
    } : optionsShouldForwardProp;
  }

  if (typeof shouldForwardProp !== 'function' && isReal) {
    shouldForwardProp = tag.__emotion_forwardProp;
  }

  return shouldForwardProp;
};

var ILLEGAL_ESCAPE_SEQUENCE_ERROR = "You have illegal escape sequence in your template literal, most likely inside content's property value.\nBecause you write your CSS inside a JavaScript string you actually have to do double escaping, so for example \"content: '\\00d7';\" should become \"content: '\\\\00d7';\".\nYou can read more about this here:\nhttps://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals#ES2018_revision_of_illegal_escape_sequences";

var Insertion = function Insertion(_ref) {
  var cache = _ref.cache,
      serialized = _ref.serialized,
      isStringTag = _ref.isStringTag;
  (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.registerStyles)(cache, serialized, isStringTag);
  (0,_emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__.useInsertionEffectAlwaysWithSyncFallback)(function () {
    return (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.insertStyles)(cache, serialized, isStringTag);
  });

  return null;
};

var createStyled = function createStyled(tag, options) {
  {
    if (tag === undefined) {
      throw new Error('You are trying to create a styled element with an undefined component.\nYou may have forgotten to import it.');
    }
  }

  var isReal = tag.__emotion_real === tag;
  var baseTag = isReal && tag.__emotion_base || tag;
  var identifierName;
  var targetClassName;

  if (options !== undefined) {
    identifierName = options.label;
    targetClassName = options.target;
  }

  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);
  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);
  var shouldUseAs = !defaultShouldForwardProp('as');
  return function () {
    // eslint-disable-next-line prefer-rest-params
    var args = arguments;
    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];

    if (identifierName !== undefined) {
      styles.push("label:" + identifierName + ";");
    }

    if (args[0] == null || args[0].raw === undefined) {
      // eslint-disable-next-line prefer-spread
      styles.push.apply(styles, args);
    } else {
      var templateStringsArr = args[0];

      if (templateStringsArr[0] === undefined) {
        console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
      }

      styles.push(templateStringsArr[0]);
      var len = args.length;
      var i = 1;

      for (; i < len; i++) {
        if (templateStringsArr[i] === undefined) {
          console.error(ILLEGAL_ESCAPE_SEQUENCE_ERROR);
        }

        styles.push(args[i], templateStringsArr[i]);
      }
    }

    var Styled = (0,_emotion_react__WEBPACK_IMPORTED_MODULE_1__.w)(function (props, cache, ref) {
      var FinalTag = shouldUseAs && props.as || baseTag;
      var className = '';
      var classInterpolations = [];
      var mergedProps = props;

      if (props.theme == null) {
        mergedProps = {};

        for (var key in props) {
          mergedProps[key] = props[key];
        }

        mergedProps.theme = react__WEBPACK_IMPORTED_MODULE_5__.useContext(_emotion_react__WEBPACK_IMPORTED_MODULE_1__.T);
      }

      if (typeof props.className === 'string') {
        className = (0,_emotion_utils__WEBPACK_IMPORTED_MODULE_4__.getRegisteredStyles)(cache.registered, classInterpolations, props.className);
      } else if (props.className != null) {
        className = props.className + " ";
      }

      var serialized = (0,_emotion_serialize__WEBPACK_IMPORTED_MODULE_2__.serializeStyles)(styles.concat(classInterpolations), cache.registered, mergedProps);
      className += cache.key + "-" + serialized.name;

      if (targetClassName !== undefined) {
        className += " " + targetClassName;
      }

      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;
      var newProps = {};

      for (var _key in props) {
        if (shouldUseAs && _key === 'as') continue;

        if (finalShouldForwardProp(_key)) {
          newProps[_key] = props[_key];
        }
      }

      newProps.className = className;

      if (ref) {
        newProps.ref = ref;
      }

      return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(react__WEBPACK_IMPORTED_MODULE_5__.Fragment, null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(Insertion, {
        cache: cache,
        serialized: serialized,
        isStringTag: typeof FinalTag === 'string'
      }), /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_5__.createElement(FinalTag, newProps));
    });
    Styled.displayName = identifierName !== undefined ? identifierName : "Styled(" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + ")";
    Styled.defaultProps = tag.defaultProps;
    Styled.__emotion_real = Styled;
    Styled.__emotion_base = baseTag;
    Styled.__emotion_styles = styles;
    Styled.__emotion_forwardProp = shouldForwardProp;
    Object.defineProperty(Styled, 'toString', {
      value: function value() {
        if (targetClassName === undefined && isDevelopment) {
          return 'NO_COMPONENT_SELECTOR';
        }

        return "." + targetClassName;
      }
    });

    Styled.withComponent = function (nextTag, nextOptions) {
      var newStyled = createStyled(nextTag, (0,_babel_runtime_helpers_esm_extends__WEBPACK_IMPORTED_MODULE_0__["default"])({}, options, nextOptions, {
        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)
      }));
      return newStyled.apply(void 0, styles);
    };

    return Styled;
  };
};




/***/ }),

/***/ "./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js":
/*!*************************************************************************************!*\
  !*** ./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ styled; }
/* harmony export */ });
/* harmony import */ var _base_dist_emotion_styled_base_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../base/dist/emotion-styled-base.browser.development.esm.js */ "./node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.development.esm.js");
/* harmony import */ var _babel_runtime_helpers_extends__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @babel/runtime/helpers/extends */ "./node_modules/@emotion/styled/node_modules/@babel/runtime/helpers/esm/extends.js");
/* harmony import */ var _emotion_serialize__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @emotion/serialize */ "./node_modules/@emotion/serialize/dist/emotion-serialize.development.esm.js");
/* harmony import */ var _emotion_use_insertion_effect_with_fallbacks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @emotion/use-insertion-effect-with-fallbacks */ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js");
/* harmony import */ var _emotion_utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @emotion/utils */ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _emotion_is_prop_valid__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @emotion/is-prop-valid */ "./node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js");









var tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG
'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];

// bind it to avoid mutating the original function
var styled = _base_dist_emotion_styled_base_browser_development_esm_js__WEBPACK_IMPORTED_MODULE_0__["default"].bind(null);
tags.forEach(function (tagName) {
  styled[tagName] = styled(tagName);
});




/***/ }),

/***/ "./node_modules/@emotion/styled/node_modules/@babel/runtime/helpers/esm/extends.js":
/*!*****************************************************************************************!*\
  !*** ./node_modules/@emotion/styled/node_modules/@babel/runtime/helpers/esm/extends.js ***!
  \*****************************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ _extends; }
/* harmony export */ });
function _extends() {
  return _extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e < arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
    }
    return n;
  }, _extends.apply(null, arguments);
}


/***/ }),

/***/ "./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js":
/*!*********************************************************************!*\
  !*** ./node_modules/@emotion/unitless/dist/emotion-unitless.esm.js ***!
  \*********************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ unitlessKeys; }
/* harmony export */ });
var unitlessKeys = {
  animationIterationCount: 1,
  aspectRatio: 1,
  borderImageOutset: 1,
  borderImageSlice: 1,
  borderImageWidth: 1,
  boxFlex: 1,
  boxFlexGroup: 1,
  boxOrdinalGroup: 1,
  columnCount: 1,
  columns: 1,
  flex: 1,
  flexGrow: 1,
  flexPositive: 1,
  flexShrink: 1,
  flexNegative: 1,
  flexOrder: 1,
  gridRow: 1,
  gridRowEnd: 1,
  gridRowSpan: 1,
  gridRowStart: 1,
  gridColumn: 1,
  gridColumnEnd: 1,
  gridColumnSpan: 1,
  gridColumnStart: 1,
  msGridRow: 1,
  msGridRowSpan: 1,
  msGridColumn: 1,
  msGridColumnSpan: 1,
  fontWeight: 1,
  lineHeight: 1,
  opacity: 1,
  order: 1,
  orphans: 1,
  scale: 1,
  tabSize: 1,
  widows: 1,
  zIndex: 1,
  zoom: 1,
  WebkitLineClamp: 1,
  // SVG-related properties
  fillOpacity: 1,
  floodOpacity: 1,
  stopOpacity: 1,
  strokeDasharray: 1,
  strokeDashoffset: 1,
  strokeMiterlimit: 1,
  strokeOpacity: 1,
  strokeWidth: 1
};




/***/ }),

/***/ "./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js":
/*!***********************************************************************************************************************************!*\
  !*** ./node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js ***!
  \***********************************************************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useInsertionEffectAlwaysWithSyncFallback: function() { return /* binding */ useInsertionEffectAlwaysWithSyncFallback; },
/* harmony export */   useInsertionEffectWithLayoutFallback: function() { return /* binding */ useInsertionEffectWithLayoutFallback; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);


var syncFallback = function syncFallback(create) {
  return create();
};

var useInsertionEffect = react__WEBPACK_IMPORTED_MODULE_0__['useInsertion' + 'Effect'] ? react__WEBPACK_IMPORTED_MODULE_0__['useInsertion' + 'Effect'] : false;
var useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback;
var useInsertionEffectWithLayoutFallback = useInsertionEffect || react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect;




/***/ }),

/***/ "./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js ***!
  \***********************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getRegisteredStyles: function() { return /* binding */ getRegisteredStyles; },
/* harmony export */   insertStyles: function() { return /* binding */ insertStyles; },
/* harmony export */   registerStyles: function() { return /* binding */ registerStyles; }
/* harmony export */ });
var isBrowser = true;

function getRegisteredStyles(registered, registeredStyles, classNames) {
  var rawClassName = '';
  classNames.split(' ').forEach(function (className) {
    if (registered[className] !== undefined) {
      registeredStyles.push(registered[className] + ";");
    } else if (className) {
      rawClassName += className + " ";
    }
  });
  return rawClassName;
}
var registerStyles = function registerStyles(cache, serialized, isStringTag) {
  var className = cache.key + "-" + serialized.name;

  if ( // we only need to add the styles to the registered cache if the
  // class name could be used further down
  // the tree but if it's a string tag, we know it won't
  // so we don't have to add it to registered cache.
  // this improves memory usage since we can avoid storing the whole style string
  (isStringTag === false || // we need to always store it if we're in compat mode and
  // in node since emotion-server relies on whether a style is in
  // the registered cache to know whether a style is global or not
  // also, note that this check will be dead code eliminated in the browser
  isBrowser === false ) && cache.registered[className] === undefined) {
    cache.registered[className] = serialized.styles;
  }
};
var insertStyles = function insertStyles(cache, serialized, isStringTag) {
  registerStyles(cache, serialized, isStringTag);
  var className = cache.key + "-" + serialized.name;

  if (cache.inserted[serialized.name] === undefined) {
    var current = serialized;

    do {
      cache.insert(serialized === current ? "." + className : '', current, cache.sheet, true);

      current = current.next;
    } while (current !== undefined);
  }
};




/***/ }),

/***/ "./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js":
/*!*****************************************************************************!*\
  !*** ./node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js ***!
  \*****************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": function() { return /* binding */ weakMemoize; }
/* harmony export */ });
var weakMemoize = function weakMemoize(func) {
  var cache = new WeakMap();
  return function (arg) {
    if (cache.has(arg)) {
      // Use non-null assertion because we just checked that the cache `has` it
      // This allows us to remove `undefined` from the return value
      return cache.get(arg);
    }

    var ret = func(arg);
    cache.set(arg, ret);
    return ret;
  };
};




/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/ArrowPathIcon.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/ArrowPathIcon.js ***!
  \***********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ArrowPathIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.993 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182m0-4.991v4.99"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ArrowPathIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/ArrowUturnLeftIcon.js":
/*!****************************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/ArrowUturnLeftIcon.js ***!
  \****************************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function ArrowUturnLeftIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M9 15 3 9m0 0 6-6M3 9h12a6 6 0 0 1 0 12h-3"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(ArrowUturnLeftIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/Bars3Icon.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/Bars3Icon.js ***!
  \*******************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function Bars3Icon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M3.75 6.75h16.5M3.75 12h16.5m-16.5 5.25h16.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(Bars3Icon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/BookOpenIcon.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/BookOpenIcon.js ***!
  \**********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function BookOpenIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M12 6.042A8.967 8.967 0 0 0 6 3.75c-1.052 0-2.062.18-3 .512v14.25A8.987 8.987 0 0 1 6 18c2.305 0 4.408.867 6 2.292m0-14.25a8.966 8.966 0 0 1 6-2.292c1.052 0 2.062.18 3 .512v14.25A8.987 8.987 0 0 0 18 18a8.967 8.967 0 0 0-6 2.292m0-14.25v14.25"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(BookOpenIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/CheckIcon.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/CheckIcon.js ***!
  \*******************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function CheckIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m4.5 12.75 6 6 9-13.5"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(CheckIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/GlobeAltIcon.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/GlobeAltIcon.js ***!
  \**********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function GlobeAltIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M12 21a9.004 9.004 0 0 0 8.716-6.747M12 21a9.004 9.004 0 0 1-8.716-6.747M12 21c2.485 0 4.5-4.03 4.5-9S14.485 3 12 3m0 18c-2.485 0-4.5-4.03-4.5-9S9.515 3 12 3m0 0a8.997 8.997 0 0 1 7.843 4.582M12 3a8.997 8.997 0 0 0-7.843 4.582m15.686 0A11.953 11.953 0 0 1 12 10.5c-2.998 0-5.74-1.1-7.843-2.918m15.686 0A8.959 8.959 0 0 1 21 12c0 .778-.099 1.533-.284 2.253m0 0A17.919 17.919 0 0 1 12 16.5c-3.162 0-6.133-.815-8.716-2.247m0 0A9.015 9.015 0 0 1 3 12c0-1.605.42-3.113 1.157-4.418"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(GlobeAltIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/LifebuoyIcon.js":
/*!**********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/LifebuoyIcon.js ***!
  \**********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function LifebuoyIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M16.712 4.33a9.027 9.027 0 0 1 1.652 1.306c.51.51.944 1.064 1.306 1.652M16.712 4.33l-3.448 4.138m3.448-4.138a9.014 9.014 0 0 0-9.424 0M19.67 7.288l-4.138 3.448m4.138-3.448a9.014 9.014 0 0 1 0 9.424m-4.138-5.976a3.736 3.736 0 0 0-.88-1.388 3.737 3.737 0 0 0-1.388-.88m2.268 2.268a3.765 3.765 0 0 1 0 2.528m-2.268-4.796a3.765 3.765 0 0 0-2.528 0m4.796 4.796c-.181.506-.475.982-.88 1.388a3.736 3.736 0 0 1-1.388.88m2.268-2.268 4.138 3.448m0 0a9.027 9.027 0 0 1-1.306 1.652c-.51.51-1.064.944-1.652 1.306m0 0-3.448-4.138m3.448 4.138a9.014 9.014 0 0 1-9.424 0m5.976-4.138a3.765 3.765 0 0 1-2.528 0m0 0a3.736 3.736 0 0 1-1.388-.88 3.737 3.737 0 0 1-.88-1.388m2.268 2.268L7.288 19.67m0 0a9.024 9.024 0 0 1-1.652-1.306 9.027 9.027 0 0 1-1.306-1.652m0 0 4.138-3.448M4.33 16.712a9.014 9.014 0 0 1 0-9.424m4.138 5.976a3.765 3.765 0 0 1 0-2.528m0 0c.181-.506.475-.982.88-1.388a3.736 3.736 0 0 1 1.388-.88m-2.268 2.268L4.33 7.288m6.406 1.18L7.288 4.33m0 0a9.024 9.024 0 0 0-1.652 1.306A9.025 9.025 0 0 0 4.33 7.288"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(LifebuoyIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/PencilIcon.js":
/*!********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/PencilIcon.js ***!
  \********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function PencilIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m16.862 4.487 1.687-1.688a1.875 1.875 0 1 1 2.652 2.652L6.832 19.82a4.5 4.5 0 0 1-1.897 1.13l-2.685.8.8-2.685a4.5 4.5 0 0 1 1.13-1.897L16.863 4.487Zm0 0L19.5 7.125"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(PencilIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/PlusIcon.js":
/*!******************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/PlusIcon.js ***!
  \******************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function PlusIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M12 4.5v15m7.5-7.5h-15"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(PlusIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/QueueListIcon.js":
/*!***********************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/QueueListIcon.js ***!
  \***********************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function QueueListIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "M3.75 12h16.5m-16.5 3.75h16.5M3.75 19.5h16.5M5.625 4.5h12.75a1.875 1.875 0 0 1 0 3.75H5.625a1.875 1.875 0 0 1 0-3.75Z"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(QueueListIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/@heroicons/react/24/outline/esm/TrashIcon.js":
/*!*******************************************************************!*\
  !*** ./node_modules/@heroicons/react/24/outline/esm/TrashIcon.js ***!
  \*******************************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");

function TrashIcon({
  title,
  titleId,
  ...props
}, svgRef) {
  return /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("svg", Object.assign({
    xmlns: "http://www.w3.org/2000/svg",
    fill: "none",
    viewBox: "0 0 24 24",
    strokeWidth: 1.5,
    stroke: "currentColor",
    "aria-hidden": "true",
    "data-slot": "icon",
    ref: svgRef,
    "aria-labelledby": titleId
  }, props), title ? /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("title", {
    id: titleId
  }, title) : null, /*#__PURE__*/react__WEBPACK_IMPORTED_MODULE_0__.createElement("path", {
    strokeLinecap: "round",
    strokeLinejoin: "round",
    d: "m14.74 9-.346 9m-4.788 0L9.26 9m9.968-3.21c.342.052.682.107 1.022.166m-1.022-.165L18.16 19.673a2.25 2.25 0 0 1-2.244 2.077H8.084a2.25 2.25 0 0 1-2.244-2.077L4.772 5.79m14.456 0a48.108 48.108 0 0 0-3.478-.397m-12 .562c.34-.059.68-.114 1.022-.165m0 0a48.11 48.11 0 0 1 3.478-.397m7.5 0v-.916c0-1.18-.91-2.164-2.09-2.201a51.964 51.964 0 0 0-3.32 0c-1.18.037-2.09 1.022-2.09 2.201v.916m7.5 0a48.667 48.667 0 0 0-7.5 0"
  }));
}
const ForwardRef = /*#__PURE__*/ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef(TrashIcon);
/* harmony default export */ __webpack_exports__["default"] = (ForwardRef);

/***/ }),

/***/ "./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js":
/*!**********************************************************************************!*\
  !*** ./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js ***!
  \**********************************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



var reactIs = __webpack_require__(/*! react-is */ "./node_modules/react-is/index.js");

/**
 * Copyright 2015, Yahoo! Inc.
 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
 */
var REACT_STATICS = {
  childContextTypes: true,
  contextType: true,
  contextTypes: true,
  defaultProps: true,
  displayName: true,
  getDefaultProps: true,
  getDerivedStateFromError: true,
  getDerivedStateFromProps: true,
  mixins: true,
  propTypes: true,
  type: true
};
var KNOWN_STATICS = {
  name: true,
  length: true,
  prototype: true,
  caller: true,
  callee: true,
  arguments: true,
  arity: true
};
var FORWARD_REF_STATICS = {
  '$$typeof': true,
  render: true,
  defaultProps: true,
  displayName: true,
  propTypes: true
};
var MEMO_STATICS = {
  '$$typeof': true,
  compare: true,
  defaultProps: true,
  displayName: true,
  propTypes: true,
  type: true
};
var TYPE_STATICS = {};
TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;

function getStatics(component) {
  // React v16.11 and below
  if (reactIs.isMemo(component)) {
    return MEMO_STATICS;
  } // React v16.12 and above


  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
}

var defineProperty = Object.defineProperty;
var getOwnPropertyNames = Object.getOwnPropertyNames;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var getPrototypeOf = Object.getPrototypeOf;
var objectPrototype = Object.prototype;
function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
  if (typeof sourceComponent !== 'string') {
    // don't hoist over string (html) components
    if (objectPrototype) {
      var inheritedComponent = getPrototypeOf(sourceComponent);

      if (inheritedComponent && inheritedComponent !== objectPrototype) {
        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
      }
    }

    var keys = getOwnPropertyNames(sourceComponent);

    if (getOwnPropertySymbols) {
      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
    }

    var targetStatics = getStatics(targetComponent);
    var sourceStatics = getStatics(sourceComponent);

    for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];

      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

        try {
          // Avoid failures from read-only properties
          defineProperty(targetComponent, key, descriptor);
        } catch (e) {}
      }
    }
  }

  return targetComponent;
}

module.exports = hoistNonReactStatics;


/***/ }),

/***/ "./node_modules/react-dom/client.js":
/*!******************************************!*\
  !*** ./node_modules/react-dom/client.js ***!
  \******************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {



var m = __webpack_require__(/*! react-dom */ "react-dom");
if (false) // removed by dead control flow
{} else {
  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  exports.createRoot = function(c, o) {
    i.usingClientEntryPoint = true;
    try {
      return m.createRoot(c, o);
    } finally {
      i.usingClientEntryPoint = false;
    }
  };
  exports.hydrateRoot = function(c, h, o) {
    i.usingClientEntryPoint = true;
    try {
      return m.hydrateRoot(c, h, o);
    } finally {
      i.usingClientEntryPoint = false;
    }
  };
}


/***/ }),

/***/ "./node_modules/react-is/cjs/react-is.development.js":
/*!***********************************************************!*\
  !*** ./node_modules/react-is/cjs/react-is.development.js ***!
  \***********************************************************/
/***/ (function(__unused_webpack_module, exports) {

/** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */





if (true) {
  (function() {
'use strict';

// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?

var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}

function typeOf(object) {
  if (typeof object === 'object' && object !== null) {
    var $$typeof = object.$$typeof;

    switch ($$typeof) {
      case REACT_ELEMENT_TYPE:
        var type = object.type;

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
          case REACT_CONCURRENT_MODE_TYPE:
          case REACT_FRAGMENT_TYPE:
          case REACT_PROFILER_TYPE:
          case REACT_STRICT_MODE_TYPE:
          case REACT_SUSPENSE_TYPE:
            return type;

          default:
            var $$typeofType = type && type.$$typeof;

            switch ($$typeofType) {
              case REACT_CONTEXT_TYPE:
              case REACT_FORWARD_REF_TYPE:
              case REACT_LAZY_TYPE:
              case REACT_MEMO_TYPE:
              case REACT_PROVIDER_TYPE:
                return $$typeofType;

              default:
                return $$typeof;
            }

        }

      case REACT_PORTAL_TYPE:
        return $$typeof;
    }
  }

  return undefined;
} // AsyncMode is deprecated along with isAsyncMode

var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

function isAsyncMode(object) {
  {
    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
    }
  }

  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
  return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
  return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
  return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
  return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
  return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
  return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
  return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
  return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
  return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
  return typeOf(object) === REACT_SUSPENSE_TYPE;
}

exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
  })();
}


/***/ }),

/***/ "./node_modules/react-is/index.js":
/*!****************************************!*\
  !*** ./node_modules/react-is/index.js ***!
  \****************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



if (false) // removed by dead control flow
{} else {
  module.exports = __webpack_require__(/*! ./cjs/react-is.development.js */ "./node_modules/react-is/cjs/react-is.development.js");
}


/***/ }),

/***/ "./node_modules/regexparam/dist/index.mjs":
/*!************************************************!*\
  !*** ./node_modules/regexparam/dist/index.mjs ***!
  \************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   inject: function() { return /* binding */ inject; },
/* harmony export */   parse: function() { return /* binding */ parse; }
/* harmony export */ });
/**
 * @param {string|RegExp} input The route pattern
 * @param {boolean} [loose] Allow open-ended matching. Ignored with `RegExp` input.
 */
function parse(input, loose) {
	if (input instanceof RegExp) return { keys:false, pattern:input };
	var c, o, tmp, ext, keys=[], pattern='', arr = input.split('/');
	arr[0] || arr.shift();

	while (tmp = arr.shift()) {
		c = tmp[0];
		if (c === '*') {
			keys.push(c);
			pattern += tmp[1] === '?' ? '(?:/(.*))?' : '/(.*)';
		} else if (c === ':') {
			o = tmp.indexOf('?', 1);
			ext = tmp.indexOf('.', 1);
			keys.push( tmp.substring(1, !!~o ? o : !!~ext ? ext : tmp.length) );
			pattern += !!~o && !~ext ? '(?:/([^/]+?))?' : '/([^/]+?)';
			if (!!~ext) pattern += (!!~o ? '?' : '') + '\\' + tmp.substring(ext);
		} else {
			pattern += '/' + tmp;
		}
	}

	return {
		keys: keys,
		pattern: new RegExp('^' + pattern + (loose ? '(?=$|\/)' : '\/?$'), 'i')
	};
}

var RGX = /(\/|^)([:*][^/]*?)(\?)?(?=[/.]|$)/g;

// error if key missing?
function inject(route, values) {
	return route.replace(RGX, (x, lead, key, optional) => {
		x = values[key=='*' ? key : key.substring(1)];
		return x ? '/'+x : (optional || key=='*') ? '' : '/' + key;
	});
}


/***/ }),

/***/ "./node_modules/stylis/src/Enum.js":
/*!*****************************************!*\
  !*** ./node_modules/stylis/src/Enum.js ***!
  \*****************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   CHARSET: function() { return /* binding */ CHARSET; },
/* harmony export */   COMMENT: function() { return /* binding */ COMMENT; },
/* harmony export */   COUNTER_STYLE: function() { return /* binding */ COUNTER_STYLE; },
/* harmony export */   DECLARATION: function() { return /* binding */ DECLARATION; },
/* harmony export */   DOCUMENT: function() { return /* binding */ DOCUMENT; },
/* harmony export */   FONT_FACE: function() { return /* binding */ FONT_FACE; },
/* harmony export */   FONT_FEATURE_VALUES: function() { return /* binding */ FONT_FEATURE_VALUES; },
/* harmony export */   IMPORT: function() { return /* binding */ IMPORT; },
/* harmony export */   KEYFRAMES: function() { return /* binding */ KEYFRAMES; },
/* harmony export */   LAYER: function() { return /* binding */ LAYER; },
/* harmony export */   MEDIA: function() { return /* binding */ MEDIA; },
/* harmony export */   MOZ: function() { return /* binding */ MOZ; },
/* harmony export */   MS: function() { return /* binding */ MS; },
/* harmony export */   NAMESPACE: function() { return /* binding */ NAMESPACE; },
/* harmony export */   PAGE: function() { return /* binding */ PAGE; },
/* harmony export */   RULESET: function() { return /* binding */ RULESET; },
/* harmony export */   SUPPORTS: function() { return /* binding */ SUPPORTS; },
/* harmony export */   VIEWPORT: function() { return /* binding */ VIEWPORT; },
/* harmony export */   WEBKIT: function() { return /* binding */ WEBKIT; }
/* harmony export */ });
var MS = '-ms-'
var MOZ = '-moz-'
var WEBKIT = '-webkit-'

var COMMENT = 'comm'
var RULESET = 'rule'
var DECLARATION = 'decl'

var PAGE = '@page'
var MEDIA = '@media'
var IMPORT = '@import'
var CHARSET = '@charset'
var VIEWPORT = '@viewport'
var SUPPORTS = '@supports'
var DOCUMENT = '@document'
var NAMESPACE = '@namespace'
var KEYFRAMES = '@keyframes'
var FONT_FACE = '@font-face'
var COUNTER_STYLE = '@counter-style'
var FONT_FEATURE_VALUES = '@font-feature-values'
var LAYER = '@layer'


/***/ }),

/***/ "./node_modules/stylis/src/Middleware.js":
/*!***********************************************!*\
  !*** ./node_modules/stylis/src/Middleware.js ***!
  \***********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   middleware: function() { return /* binding */ middleware; },
/* harmony export */   namespace: function() { return /* binding */ namespace; },
/* harmony export */   prefixer: function() { return /* binding */ prefixer; },
/* harmony export */   rulesheet: function() { return /* binding */ rulesheet; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "./node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "./node_modules/stylis/src/Utility.js");
/* harmony import */ var _Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Tokenizer.js */ "./node_modules/stylis/src/Tokenizer.js");
/* harmony import */ var _Serializer_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Serializer.js */ "./node_modules/stylis/src/Serializer.js");
/* harmony import */ var _Prefixer_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Prefixer.js */ "./node_modules/stylis/src/Prefixer.js");






/**
 * @param {function[]} collection
 * @return {function}
 */
function middleware (collection) {
	var length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(collection)

	return function (element, index, children, callback) {
		var output = ''

		for (var i = 0; i < length; i++)
			output += collection[i](element, index, children, callback) || ''

		return output
	}
}

/**
 * @param {function} callback
 * @return {function}
 */
function rulesheet (callback) {
	return function (element) {
		if (!element.root)
			if (element = element.return)
				callback(element)
	}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 */
function prefixer (element, index, children, callback) {
	if (element.length > -1)
		if (!element.return)
			switch (element.type) {
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION: element.return = (0,_Prefixer_js__WEBPACK_IMPORTED_MODULE_4__.prefix)(element.value, element.length, children)
					return
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.KEYFRAMES:
					return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {value: (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(element.value, '@', '@' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT)})], callback)
				case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET:
					if (element.length)
						return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.combine)(element.props, function (value) {
							switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /(::plac\w+|:read-\w+)/)) {
								// :read-(only|write)
								case ':read-only': case ':read-write':
									return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(read-\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + '$1')]})], callback)
								// :placeholder
								case '::placeholder':
									return (0,_Serializer_js__WEBPACK_IMPORTED_MODULE_3__.serialize)([
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'input-$1')]}),
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + '$1')]}),
										(0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.copy)(element, {props: [(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /:(plac\w+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'input-$1')]})
									], callback)
							}

							return ''
						})
			}
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 */
function namespace (element) {
	switch (element.type) {
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET:
			element.props = element.props.map(function (value) {
				return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.combine)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.tokenize)(value), function (value, index, children) {
					switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 0)) {
						// \f
						case 12:
							return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 1, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(value))
						// \0 ( + > ~
						case 0: case 40: case 43: case 62: case 126:
							return value
						// :
						case 58:
							if (children[++index] === 'global')
								children[index] = '', children[++index] = '\f' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(children[index], index = 1, -1)
						// \s
						case 32:
							return index === 1 ? '' : value
						default:
							switch (index) {
								case 0: element = value
									return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children) > 1 ? '' : value
								case index = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children) - 1: case 2:
									return index === 2 ? value + element + element : value + element
								default:
									return value
							}
					}
				})
			})
	}
}


/***/ }),

/***/ "./node_modules/stylis/src/Parser.js":
/*!*******************************************!*\
  !*** ./node_modules/stylis/src/Parser.js ***!
  \*******************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   comment: function() { return /* binding */ comment; },
/* harmony export */   compile: function() { return /* binding */ compile; },
/* harmony export */   declaration: function() { return /* binding */ declaration; },
/* harmony export */   parse: function() { return /* binding */ parse; },
/* harmony export */   ruleset: function() { return /* binding */ ruleset; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "./node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "./node_modules/stylis/src/Utility.js");
/* harmony import */ var _Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Tokenizer.js */ "./node_modules/stylis/src/Tokenizer.js");




/**
 * @param {string} value
 * @return {object[]}
 */
function compile (value) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.dealloc)(parse('', null, null, null, [''], value = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.alloc)(value), 0, [0], value))
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {string[]} rule
 * @param {string[]} rules
 * @param {string[]} rulesets
 * @param {number[]} pseudo
 * @param {number[]} points
 * @param {string[]} declarations
 * @return {object}
 */
function parse (value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
	var index = 0
	var offset = 0
	var length = pseudo
	var atrule = 0
	var property = 0
	var previous = 0
	var variable = 1
	var scanning = 1
	var ampersand = 1
	var character = 0
	var type = ''
	var props = rules
	var children = rulesets
	var reference = rule
	var characters = type

	while (scanning)
		switch (previous = character, character = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)()) {
			// (
			case 40:
				if (previous != 108 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(characters, length - 1) == 58) {
					if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(characters += (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)(character), '&', '&\f'), '&\f') != -1)
						ampersand = -1
					break
				}
			// " ' [
			case 34: case 39: case 91:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)(character)
				break
			// \t \n \r \s
			case 9: case 10: case 13: case 32:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.whitespace)(previous)
				break
			// \
			case 92:
				characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.escaping)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)() - 1, 7)
				continue
			// /
			case 47:
				switch ((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)()) {
					case 42: case 47:
						;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(comment((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.commenter)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)(), (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)()), root, parent), declarations)
						break
					default:
						characters += '/'
				}
				break
			// {
			case 123 * variable:
				points[index++] = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) * ampersand
			// } ; \0
			case 125 * variable: case 59: case 0:
				switch (character) {
					// \0 }
					case 0: case 125: scanning = 0
					// ;
					case 59 + offset: if (ampersand == -1) characters = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(characters, /\f/g, '')
						if (property > 0 && ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) - length))
							(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(property > 32 ? declaration(characters + ';', rule, parent, length - 1) : declaration((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(characters, ' ', '') + ';', rule, parent, length - 2), declarations)
						break
					// @ ;
					case 59: characters += ';'
					// { rule/at-rule
					default:
						;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length), rulesets)

						if (character === 123)
							if (offset === 0)
								parse(characters, root, reference, reference, props, rulesets, length, points, children)
							else
								switch (atrule === 99 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(characters, 3) === 110 ? 100 : atrule) {
									// d l m s
									case 100: case 108: case 109: case 115:
										parse(value, reference, reference, rule && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.append)(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length), children), rules, children, length, points, rule ? props : children)
										break
									default:
										parse(characters, reference, reference, reference, [''], children, 0, points, children)
								}
				}

				index = offset = property = 0, variable = ampersand = 1, type = characters = '', length = pseudo
				break
			// :
			case 58:
				length = 1 + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters), property = previous
			default:
				if (variable < 1)
					if (character == 123)
						--variable
					else if (character == 125 && variable++ == 0 && (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.prev)() == 125)
						continue

				switch (characters += (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.from)(character), character * variable) {
					// &
					case 38:
						ampersand = offset > 0 ? 1 : (characters += '\f', -1)
						break
					// ,
					case 44:
						points[index++] = ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) - 1) * ampersand, ampersand = 1
						break
					// @
					case 64:
						// -
						if ((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)() === 45)
							characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.delimit)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.next)())

						atrule = (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.peek)(), offset = length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(type = characters += (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.identifier)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.caret)())), character++
						break
					// -
					case 45:
						if (previous === 45 && (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(characters) == 2)
							variable = 0
				}
		}

	return rulesets
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} index
 * @param {number} offset
 * @param {string[]} rules
 * @param {number[]} points
 * @param {string} type
 * @param {string[]} props
 * @param {string[]} children
 * @param {number} length
 * @return {object}
 */
function ruleset (value, root, parent, index, offset, rules, points, type, props, children, length) {
	var post = offset - 1
	var rule = offset === 0 ? rules : ['']
	var size = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(rule)

	for (var i = 0, j = 0, k = 0; i < index; ++i)
		for (var x = 0, y = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, post + 1, post = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.abs)(j = points[i])), z = value; x < size; ++x)
			if (z = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.trim)(j > 0 ? rule[x] + ' ' + y : (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(y, /&\f/g, rule[x])))
				props[k++] = z

	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, offset === 0 ? _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET : type, props, children, length)
}

/**
 * @param {number} value
 * @param {object} root
 * @param {object?} parent
 * @return {object}
 */
function comment (value, root, parent) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.COMMENT, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.from)((0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.char)()), (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 2, -2), 0)
}

/**
 * @param {string} value
 * @param {object} root
 * @param {object?} parent
 * @param {number} length
 * @return {object}
 */
function declaration (value, root, parent, length) {
	return (0,_Tokenizer_js__WEBPACK_IMPORTED_MODULE_2__.node)(value, root, parent, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, 0, length), (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, length + 1, -1), length)
}


/***/ }),

/***/ "./node_modules/stylis/src/Prefixer.js":
/*!*********************************************!*\
  !*** ./node_modules/stylis/src/Prefixer.js ***!
  \*********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   prefix: function() { return /* binding */ prefix; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "./node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "./node_modules/stylis/src/Utility.js");



/**
 * @param {string} value
 * @param {number} length
 * @param {object[]} children
 * @return {string}
 */
function prefix (value, length, children) {
	switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.hash)(value, length)) {
		// color-adjust
		case 5103:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'print-' + value + value
		// animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)
		case 5737: case 4201: case 3177: case 3433: case 1641: case 4457: case 2921:
		// text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break
		case 5572: case 6356: case 5844: case 3191: case 6645: case 3005:
		// mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,
		case 6391: case 5879: case 5623: case 6135: case 4599: case 4855:
		// background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)
		case 4215: case 6389: case 5109: case 5365: case 5621: case 3829:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + value
		// tab-size
		case 4789:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + value + value
		// appearance, user-select, transform, hyphens, text-size-adjust
		case 5349: case 4246: case 4810: case 6968: case 2756:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + value + value
		// writing-mode
		case 5936:
			switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 11)) {
				// vertical-l(r)
				case 114:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb') + value
				// vertical-r(l)
				case 108:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'tb-rl') + value
				// horizontal(-)tb
				case 45:
					return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /[svh]\w+-[tblr]{2}/, 'lr') + value
				// default: fallthrough to below
			}
		// flex, flex-direction, scroll-snap-type, writing-mode
		case 6828: case 4268: case 2903:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + value + value
		// order
		case 6165:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-' + value + value
		// align-items
		case 5187:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(\w+).+(:[^]+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-$1$2' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-$1$2') + value
		// align-self
		case 5443:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-item-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /flex-|-self/g, '') + (!(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /flex-|baseline/) ? _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-row-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /flex-|-self/g, '') : '') + value
		// align-content
		case 4675:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-line-pack' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /align-content|flex-|-self/g, '') + value
		// flex-shrink
		case 5548:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'shrink', 'negative') + value
		// flex-basis
		case 5292:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'basis', 'preferred-size') + value
		// flex-grow
		case 6060:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-grow', '') + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'grow', 'positive') + value
		// transition
		case 4554:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /([^-])(transform)/g, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2') + value
		// cursor
		case 6187:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(zoom-|grab)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1'), /(image-set)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1'), value, '') + value
		// background, background-image
		case 5495: case 3959:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(image-set\([^]*)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1' + '$`$1')
		// justify-content
		case 4968:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)(flex-)?(.*)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + 'box-pack:$3' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + value + value
		// justify-self
		case 4200:
			if (!(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /flex-|baseline/)) return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-column-align' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.substr)(value, length) + value
			break
		// grid-template-(columns|rows)
		case 2592: case 3360:
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'template-', '') + value
		// grid-(row|column)-start
		case 4384: case 3616:
			if (children && children.some(function (element, index) { return length = index, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(element.props, /grid-\w+-end/) })) {
				return ~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(value + (children = children[length].value), 'span') ? value : (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-start', '') + value + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + 'grid-row-span:' + (~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(children, 'span') ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(children, /\d+/) : +(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(children, /\d+/) - +(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(value, /\d+/)) + ';')
			}
			return _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-start', '') + value
		// grid-(row|column)-end
		case 4896: case 4128:
			return (children && children.some(function (element) { return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.match)(element.props, /grid-\w+-start/) })) ? value : _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, '-end', '-span'), 'span ', '') + value
		// (margin|padding)-inline-(start|end)
		case 4095: case 3583: case 4068: case 2532:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+)-inline(.+)/, _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$1$2') + value
		// (min|max)?(width|height|inline-size|block-size)
		case 8116: case 7059: case 5753: case 5535:
		case 5445: case 5701: case 4933: case 4677:
		case 5533: case 5789: case 5021: case 4765:
			// stretch, max-content, min-content, fill-available
			if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(value) - 1 - length > 6)
				switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 1)) {
					// (m)ax-content, (m)in-content
					case 109:
						// -
						if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 4) !== 45)
							break
					// (f)ill-available, (f)it-content
					case 102:
						return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)(.+)-([^]+)/, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2-$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MOZ + ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 3) == 108 ? '$3' : '$2-$3')) + value
					// (s)tretch
					case 115:
						return ~(0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.indexof)(value, 'stretch') ? prefix((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'stretch', 'fill-available'), length, children) + value : value
				}
			break
		// grid-(column|row)
		case 5152: case 5920:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+?):(\d+)(\s*\/\s*(span)?\s*(\d+))?(.*)/, function (_, a, b, c, d, e, f) { return (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + a + ':' + b + f) + (c ? (_Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + a + '-span:' + (d ? e : +e - +b)) + f : '') + value })
		// position: sticky
		case 4949:
			// stick(y)?
			if ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, length + 6) === 121)
				return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, ':', ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT) + value
			break
		// display: (flex|inline-flex|grid|inline-grid)
		case 6444:
			switch ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 14) === 45 ? 18 : 11)) {
				// (inline-)?fle(x)
				case 120:
					return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, /(.+:)([^;\s!]+)(;|(\s+)?!.+)?/, '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + ((0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.charat)(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.WEBKIT + '$2$3' + '$1' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS + '$2box$3') + value
				// (inline-)?gri(d)
				case 100:
					return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, ':', ':' + _Enum_js__WEBPACK_IMPORTED_MODULE_0__.MS) + value
			}
			break
		// scroll-margin, scroll-margin-(top|right|bottom|left)
		case 5719: case 2647: case 2135: case 3927: case 2391:
			return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.replace)(value, 'scroll-', 'scroll-snap-') + value
	}

	return value
}


/***/ }),

/***/ "./node_modules/stylis/src/Serializer.js":
/*!***********************************************!*\
  !*** ./node_modules/stylis/src/Serializer.js ***!
  \***********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   serialize: function() { return /* binding */ serialize; },
/* harmony export */   stringify: function() { return /* binding */ stringify; }
/* harmony export */ });
/* harmony import */ var _Enum_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Enum.js */ "./node_modules/stylis/src/Enum.js");
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utility.js */ "./node_modules/stylis/src/Utility.js");



/**
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function serialize (children, callback) {
	var output = ''
	var length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.sizeof)(children)

	for (var i = 0; i < length; i++)
		output += callback(children[i], i, children, callback) || ''

	return output
}

/**
 * @param {object} element
 * @param {number} index
 * @param {object[]} children
 * @param {function} callback
 * @return {string}
 */
function stringify (element, index, children, callback) {
	switch (element.type) {
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.LAYER: if (element.children.length) break
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.IMPORT: case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.DECLARATION: return element.return = element.return || element.value
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.COMMENT: return ''
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.KEYFRAMES: return element.return = element.value + '{' + serialize(element.children, callback) + '}'
		case _Enum_js__WEBPACK_IMPORTED_MODULE_0__.RULESET: element.value = element.props.join(',')
	}

	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_1__.strlen)(children = serialize(element.children, callback)) ? element.return = element.value + '{' + children + '}' : ''
}


/***/ }),

/***/ "./node_modules/stylis/src/Tokenizer.js":
/*!**********************************************!*\
  !*** ./node_modules/stylis/src/Tokenizer.js ***!
  \**********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   alloc: function() { return /* binding */ alloc; },
/* harmony export */   caret: function() { return /* binding */ caret; },
/* harmony export */   char: function() { return /* binding */ char; },
/* harmony export */   character: function() { return /* binding */ character; },
/* harmony export */   characters: function() { return /* binding */ characters; },
/* harmony export */   column: function() { return /* binding */ column; },
/* harmony export */   commenter: function() { return /* binding */ commenter; },
/* harmony export */   copy: function() { return /* binding */ copy; },
/* harmony export */   dealloc: function() { return /* binding */ dealloc; },
/* harmony export */   delimit: function() { return /* binding */ delimit; },
/* harmony export */   delimiter: function() { return /* binding */ delimiter; },
/* harmony export */   escaping: function() { return /* binding */ escaping; },
/* harmony export */   identifier: function() { return /* binding */ identifier; },
/* harmony export */   length: function() { return /* binding */ length; },
/* harmony export */   line: function() { return /* binding */ line; },
/* harmony export */   next: function() { return /* binding */ next; },
/* harmony export */   node: function() { return /* binding */ node; },
/* harmony export */   peek: function() { return /* binding */ peek; },
/* harmony export */   position: function() { return /* binding */ position; },
/* harmony export */   prev: function() { return /* binding */ prev; },
/* harmony export */   slice: function() { return /* binding */ slice; },
/* harmony export */   token: function() { return /* binding */ token; },
/* harmony export */   tokenize: function() { return /* binding */ tokenize; },
/* harmony export */   tokenizer: function() { return /* binding */ tokenizer; },
/* harmony export */   whitespace: function() { return /* binding */ whitespace; }
/* harmony export */ });
/* harmony import */ var _Utility_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Utility.js */ "./node_modules/stylis/src/Utility.js");


var line = 1
var column = 1
var length = 0
var position = 0
var character = 0
var characters = ''

/**
 * @param {string} value
 * @param {object | null} root
 * @param {object | null} parent
 * @param {string} type
 * @param {string[] | string} props
 * @param {object[] | string} children
 * @param {number} length
 */
function node (value, root, parent, type, props, children, length) {
	return {value: value, root: root, parent: parent, type: type, props: props, children: children, line: line, column: column, length: length, return: ''}
}

/**
 * @param {object} root
 * @param {object} props
 * @return {object}
 */
function copy (root, props) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.assign)(node('', null, null, '', null, null, 0), root, {length: -root.length}, props)
}

/**
 * @return {number}
 */
function char () {
	return character
}

/**
 * @return {number}
 */
function prev () {
	character = position > 0 ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, --position) : 0

	if (column--, character === 10)
		column = 1, line--

	return character
}

/**
 * @return {number}
 */
function next () {
	character = position < length ? (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, position++) : 0

	if (column++, character === 10)
		column = 1, line++

	return character
}

/**
 * @return {number}
 */
function peek () {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.charat)(characters, position)
}

/**
 * @return {number}
 */
function caret () {
	return position
}

/**
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function slice (begin, end) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.substr)(characters, begin, end)
}

/**
 * @param {number} type
 * @return {number}
 */
function token (type) {
	switch (type) {
		// \0 \t \n \r \s whitespace token
		case 0: case 9: case 10: case 13: case 32:
			return 5
		// ! + , / > @ ~ isolate token
		case 33: case 43: case 44: case 47: case 62: case 64: case 126:
		// ; { } breakpoint token
		case 59: case 123: case 125:
			return 4
		// : accompanied token
		case 58:
			return 3
		// " ' ( [ opening delimit token
		case 34: case 39: case 40: case 91:
			return 2
		// ) ] closing delimit token
		case 41: case 93:
			return 1
	}

	return 0
}

/**
 * @param {string} value
 * @return {any[]}
 */
function alloc (value) {
	return line = column = 1, length = (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.strlen)(characters = value), position = 0, []
}

/**
 * @param {any} value
 * @return {any}
 */
function dealloc (value) {
	return characters = '', value
}

/**
 * @param {number} type
 * @return {string}
 */
function delimit (type) {
	return (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.trim)(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)))
}

/**
 * @param {string} value
 * @return {string[]}
 */
function tokenize (value) {
	return dealloc(tokenizer(alloc(value)))
}

/**
 * @param {number} type
 * @return {string}
 */
function whitespace (type) {
	while (character = peek())
		if (character < 33)
			next()
		else
			break

	return token(type) > 2 || token(character) > 3 ? '' : ' '
}

/**
 * @param {string[]} children
 * @return {string[]}
 */
function tokenizer (children) {
	while (next())
		switch (token(character)) {
			case 0: (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)(identifier(position - 1), children)
				break
			case 2: ;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)(delimit(character), children)
				break
			default: ;(0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.append)((0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.from)(character), children)
		}

	return children
}

/**
 * @param {number} index
 * @param {number} count
 * @return {string}
 */
function escaping (index, count) {
	while (--count && next())
		// not 0-9 A-F a-f
		if (character < 48 || character > 102 || (character > 57 && character < 65) || (character > 70 && character < 97))
			break

	return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32))
}

/**
 * @param {number} type
 * @return {number}
 */
function delimiter (type) {
	while (next())
		switch (character) {
			// ] ) " '
			case type:
				return position
			// " '
			case 34: case 39:
				if (type !== 34 && type !== 39)
					delimiter(character)
				break
			// (
			case 40:
				if (type === 41)
					delimiter(type)
				break
			// \
			case 92:
				next()
				break
		}

	return position
}

/**
 * @param {number} type
 * @param {number} index
 * @return {number}
 */
function commenter (type, index) {
	while (next())
		// //
		if (type + character === 47 + 10)
			break
		// /*
		else if (type + character === 42 + 42 && peek() === 47)
			break

	return '/*' + slice(index, position - 1) + '*' + (0,_Utility_js__WEBPACK_IMPORTED_MODULE_0__.from)(type === 47 ? type : next())
}

/**
 * @param {number} index
 * @return {string}
 */
function identifier (index) {
	while (!token(peek()))
		next()

	return slice(index, position)
}


/***/ }),

/***/ "./node_modules/stylis/src/Utility.js":
/*!********************************************!*\
  !*** ./node_modules/stylis/src/Utility.js ***!
  \********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   abs: function() { return /* binding */ abs; },
/* harmony export */   append: function() { return /* binding */ append; },
/* harmony export */   assign: function() { return /* binding */ assign; },
/* harmony export */   charat: function() { return /* binding */ charat; },
/* harmony export */   combine: function() { return /* binding */ combine; },
/* harmony export */   from: function() { return /* binding */ from; },
/* harmony export */   hash: function() { return /* binding */ hash; },
/* harmony export */   indexof: function() { return /* binding */ indexof; },
/* harmony export */   match: function() { return /* binding */ match; },
/* harmony export */   replace: function() { return /* binding */ replace; },
/* harmony export */   sizeof: function() { return /* binding */ sizeof; },
/* harmony export */   strlen: function() { return /* binding */ strlen; },
/* harmony export */   substr: function() { return /* binding */ substr; },
/* harmony export */   trim: function() { return /* binding */ trim; }
/* harmony export */ });
/**
 * @param {number}
 * @return {number}
 */
var abs = Math.abs

/**
 * @param {number}
 * @return {string}
 */
var from = String.fromCharCode

/**
 * @param {object}
 * @return {object}
 */
var assign = Object.assign

/**
 * @param {string} value
 * @param {number} length
 * @return {number}
 */
function hash (value, length) {
	return charat(value, 0) ^ 45 ? (((((((length << 2) ^ charat(value, 0)) << 2) ^ charat(value, 1)) << 2) ^ charat(value, 2)) << 2) ^ charat(value, 3) : 0
}

/**
 * @param {string} value
 * @return {string}
 */
function trim (value) {
	return value.trim()
}

/**
 * @param {string} value
 * @param {RegExp} pattern
 * @return {string?}
 */
function match (value, pattern) {
	return (value = pattern.exec(value)) ? value[0] : value
}

/**
 * @param {string} value
 * @param {(string|RegExp)} pattern
 * @param {string} replacement
 * @return {string}
 */
function replace (value, pattern, replacement) {
	return value.replace(pattern, replacement)
}

/**
 * @param {string} value
 * @param {string} search
 * @return {number}
 */
function indexof (value, search) {
	return value.indexOf(search)
}

/**
 * @param {string} value
 * @param {number} index
 * @return {number}
 */
function charat (value, index) {
	return value.charCodeAt(index) | 0
}

/**
 * @param {string} value
 * @param {number} begin
 * @param {number} end
 * @return {string}
 */
function substr (value, begin, end) {
	return value.slice(begin, end)
}

/**
 * @param {string} value
 * @return {number}
 */
function strlen (value) {
	return value.length
}

/**
 * @param {any[]} value
 * @return {number}
 */
function sizeof (value) {
	return value.length
}

/**
 * @param {any} value
 * @param {any[]} array
 * @return {any}
 */
function append (value, array) {
	return array.push(value), value
}

/**
 * @param {string[]} array
 * @param {function} callback
 * @return {string}
 */
function combine (array, callback) {
	return array.map(callback).join('')
}


/***/ }),

/***/ "./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js":
/*!**********************************************************************************************!*\
  !*** ./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js ***!
  \**********************************************************************************************/
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {

/**
 * @license React
 * use-sync-external-store-shim.development.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */


 true &&
  (function () {
    function is(x, y) {
      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);
    }
    function useSyncExternalStore$2(subscribe, getSnapshot) {
      didWarnOld18Alpha ||
        void 0 === React.startTransition ||
        ((didWarnOld18Alpha = !0),
        console.error(
          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
        ));
      var value = getSnapshot();
      if (!didWarnUncachedGetSnapshot) {
        var cachedValue = getSnapshot();
        objectIs(value, cachedValue) ||
          (console.error(
            "The result of getSnapshot should be cached to avoid an infinite loop"
          ),
          (didWarnUncachedGetSnapshot = !0));
      }
      cachedValue = useState({
        inst: { value: value, getSnapshot: getSnapshot }
      });
      var inst = cachedValue[0].inst,
        forceUpdate = cachedValue[1];
      useLayoutEffect(
        function () {
          inst.value = value;
          inst.getSnapshot = getSnapshot;
          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
        },
        [subscribe, value, getSnapshot]
      );
      useEffect(
        function () {
          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
          return subscribe(function () {
            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });
          });
        },
        [subscribe]
      );
      useDebugValue(value);
      return value;
    }
    function checkIfSnapshotChanged(inst) {
      var latestGetSnapshot = inst.getSnapshot;
      inst = inst.value;
      try {
        var nextValue = latestGetSnapshot();
        return !objectIs(inst, nextValue);
      } catch (error) {
        return !0;
      }
    }
    function useSyncExternalStore$1(subscribe, getSnapshot) {
      return getSnapshot();
    }
    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
      "function" ===
        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&
      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
    var React = __webpack_require__(/*! react */ "react"),
      objectIs = "function" === typeof Object.is ? Object.is : is,
      useState = React.useState,
      useEffect = React.useEffect,
      useLayoutEffect = React.useLayoutEffect,
      useDebugValue = React.useDebugValue,
      didWarnOld18Alpha = !1,
      didWarnUncachedGetSnapshot = !1,
      shim =
        "undefined" === typeof window ||
        "undefined" === typeof window.document ||
        "undefined" === typeof window.document.createElement
          ? useSyncExternalStore$1
          : useSyncExternalStore$2;
    exports.useSyncExternalStore =
      void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
    "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
      "function" ===
        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&
      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
  })();


/***/ }),

/***/ "./node_modules/use-sync-external-store/shim/index.js":
/*!************************************************************!*\
  !*** ./node_modules/use-sync-external-store/shim/index.js ***!
  \************************************************************/
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {



if (false) // removed by dead control flow
{} else {
  module.exports = __webpack_require__(/*! ../cjs/use-sync-external-store-shim.development.js */ "./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js");
}


/***/ }),

/***/ "./node_modules/wouter/esm/index.js":
/*!******************************************!*\
  !*** ./node_modules/wouter/esm/index.js ***!
  \******************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Link: function() { return /* binding */ Link; },
/* harmony export */   Redirect: function() { return /* binding */ Redirect; },
/* harmony export */   Route: function() { return /* binding */ Route; },
/* harmony export */   Router: function() { return /* binding */ Router; },
/* harmony export */   Switch: function() { return /* binding */ Switch; },
/* harmony export */   matchRoute: function() { return /* binding */ matchRoute; },
/* harmony export */   useLocation: function() { return /* binding */ useLocation; },
/* harmony export */   useParams: function() { return /* binding */ useParams; },
/* harmony export */   useRoute: function() { return /* binding */ useRoute; },
/* harmony export */   useRouter: function() { return /* binding */ useRouter; },
/* harmony export */   useSearch: function() { return /* binding */ useSearch; },
/* harmony export */   useSearchParams: function() { return /* binding */ useSearchParams; }
/* harmony export */ });
/* harmony import */ var regexparam__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! regexparam */ "./node_modules/regexparam/dist/index.mjs");
/* harmony import */ var _use_browser_location_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./use-browser-location.js */ "./node_modules/wouter/esm/use-browser-location.js");
/* harmony import */ var _react_deps_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./react-deps.js */ "./node_modules/wouter/esm/react-deps.js");




/*
 * Transforms `path` into its relative `base` version
 * If base isn't part of the path provided returns absolute path e.g. `~/app`
 */
const _relativePath = (base, path) =>
  !path.toLowerCase().indexOf(base.toLowerCase())
    ? path.slice(base.length) || "/"
    : "~" + path;

/**
 * When basepath is `undefined` or '/' it is ignored (we assume it's empty string)
 */
const baseDefaults = (base = "") => (base === "/" ? "" : base);

const absolutePath = (to, base) =>
  to[0] === "~" ? to.slice(1) : baseDefaults(base) + to;

const relativePath = (base = "", path) =>
  _relativePath(unescape(baseDefaults(base)), unescape(path));

/*
 * Removes leading question mark
 */
const stripQm = (str) => (str[0] === "?" ? str.slice(1) : str);

/*
 * decodes escape sequences such as %20
 */
const unescape = (str) => {
  try {
    return decodeURI(str);
  } catch (_e) {
    // fail-safe mode: if string can't be decoded do nothing
    return str;
  }
};

const sanitizeSearch = (search) => unescape(stripQm(search));

/*
 * Router and router context. Router is a lightweight object that represents the current
 * routing options: how location is managed, base path etc.
 *
 * There is a default router present for most of the use cases, however it can be overridden
 * via the <Router /> component.
 */

const defaultRouter = {
  hook: _use_browser_location_js__WEBPACK_IMPORTED_MODULE_1__.useBrowserLocation,
  searchHook: _use_browser_location_js__WEBPACK_IMPORTED_MODULE_1__.useSearch,
  parser: regexparam__WEBPACK_IMPORTED_MODULE_0__.parse,
  base: "",
  // this option is used to override the current location during SSR
  ssrPath: undefined,
  ssrSearch: undefined,
  // optional context to track render state during SSR
  ssrContext: undefined,
  // customizes how `href` props are transformed for <Link />
  hrefs: (x) => x,
};

const RouterCtx = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createContext)(defaultRouter);

// gets the closest parent router from the context
const useRouter = () => (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useContext)(RouterCtx);

/**
 * Parameters context. Used by `useParams()` to get the
 * matched params from the innermost `Route` component.
 */

const Params0 = {},
  ParamsCtx = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createContext)(Params0);

const useParams = () => (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useContext)(ParamsCtx);

/*
 * Part 1, Hooks API: useRoute and useLocation
 */

// Internal version of useLocation to avoid redundant useRouter calls

const useLocationFromRouter = (router) => {
  const [location, navigate] = router.hook(router);

  // the function reference should stay the same between re-renders, so that
  // it can be passed down as an element prop without any performance concerns.
  // (This is achieved via `useEvent`.)
  return [
    relativePath(router.base, location),
    (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useEvent)((to, navOpts) => navigate(absolutePath(to, router.base), navOpts)),
  ];
};

const useLocation = () => useLocationFromRouter(useRouter());

const useSearch = () => {
  const router = useRouter();
  return sanitizeSearch(router.searchHook(router));
};

const matchRoute = (parser, route, path, loose) => {
  // if the input is a regexp, skip parsing
  const { pattern, keys } =
    route instanceof RegExp
      ? { keys: false, pattern: route }
      : parser(route || "*", loose);

  // array destructuring loses keys, so this is done in two steps
  const result = pattern.exec(path) || [];

  // when parser is in "loose" mode, `$base` is equal to the
  // first part of the route that matches the pattern
  // (e.g. for pattern `/a/:b` and path `/a/1/2/3` the `$base` is `a/1`)
  // we use this for route nesting
  const [$base, ...matches] = result;

  return $base !== undefined
    ? [
        true,

        (() => {
          // for regex paths, `keys` will always be false

          // an object with parameters matched, e.g. { foo: "bar" } for "/:foo"
          // we "zip" two arrays here to construct the object
          // ["foo"], ["bar"] → { foo: "bar" }
          const groups =
            keys !== false
              ? Object.fromEntries(keys.map((key, i) => [key, matches[i]]))
              : result.groups;

          // convert the array to an instance of object
          // this makes it easier to integrate with the existing param implementation
          let obj = { ...matches };

          // merge named capture groups with matches array
          groups && Object.assign(obj, groups);

          return obj;
        })(),

        // the third value if only present when parser is in "loose" mode,
        // so that we can extract the base path for nested routes
        ...(loose ? [$base] : []),
      ]
    : [false, null];
};

const useRoute = (pattern) =>
  matchRoute(useRouter().parser, pattern, useLocation()[0]);

/*
 * Part 2, Low Carb Router API: Router, Route, Link, Switch
 */

const Router = ({ children, ...props }) => {
  // the router we will inherit from - it is the closest router in the tree,
  // unless the custom `hook` is provided (in that case it's the default one)
  const parent_ = useRouter();
  const parent = props.hook ? defaultRouter : parent_;

  // holds to the context value: the router object
  let value = parent;

  // when `ssrPath` contains a `?` character, we can extract the search from it
  const [path, search] = props.ssrPath?.split("?") ?? [];
  if (search) (props.ssrSearch = search), (props.ssrPath = path);

  // hooks can define their own `href` formatter (e.g. for hash location)
  props.hrefs = props.hrefs ?? props.hook?.hrefs;

  // what is happening below: to avoid unnecessary rerenders in child components,
  // we ensure that the router object reference is stable, unless there are any
  // changes that require reload (e.g. `base` prop changes -> all components that
  // get the router from the context should rerender, even if the component is memoized).
  // the expected behaviour is:
  //
  //   1) when the resulted router is no different from the parent, use parent
  //   2) if the custom `hook` prop is provided, we always inherit from the
  //      default router instead. this resets all previously overridden options.
  //   3) when the router is customized here, it should stay stable between renders
  let ref = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useRef)({}),
    prev = ref.current,
    next = prev;

  for (let k in parent) {
    const option =
      k === "base"
        ? /* base is special case, it is appended to the parent's base */
          parent[k] + (props[k] || "")
        : props[k] || parent[k];

    if (prev === next && option !== next[k]) {
      ref.current = next = { ...next };
    }

    next[k] = option;

    // the new router is no different from the parent or from the memoized value, use parent
    if (option !== parent[k] || option !== value[k]) value = next;
  }

  return (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createElement)(RouterCtx.Provider, { value, children });
};

const h_route = ({ children, component }, params) => {
  // React-Router style `component` prop
  if (component) return (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createElement)(component, { params });

  // support render prop or plain children
  return typeof children === "function" ? children(params) : children;
};

// Cache params object between renders if values are shallow equal
const useCachedParams = (value) => {
  let prev = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useRef)(Params0);
  const curr = prev.current;
  return (prev.current =
    // Update cache if number of params changed or any value changed
    Object.keys(value).length !== Object.keys(curr).length ||
    Object.entries(value).some(([k, v]) => v !== curr[k])
      ? value // Return new value if there are changes
      : curr); // Return cached value if nothing changed
};

function useSearchParams() {
  const [location, navigate] = useLocation();

  const search = useSearch();
  const searchParams = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useMemo)(() => new URLSearchParams(search), [search]);

  // cached value before next render, so you can call setSearchParams multiple times
  let tempSearchParams = searchParams;

  const setSearchParams = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useEvent)((nextInit, options) => {
    tempSearchParams = new URLSearchParams(
      typeof nextInit === "function" ? nextInit(tempSearchParams) : nextInit
    );
    navigate(location + "?" + tempSearchParams, options);
  });

  return [searchParams, setSearchParams];
}

const Route = ({ path, nest, match, ...renderProps }) => {
  const router = useRouter();
  const [location] = useLocationFromRouter(router);

  const [matches, routeParams, base] =
    // `match` is a special prop to give up control to the parent,
    // it is used by the `Switch` to avoid double matching
    match ?? matchRoute(router.parser, path, location, nest);

  // when `routeParams` is `null` (there was no match), the argument
  // below becomes {...null} = {}, see the Object Spread specs
  // https://tc39.es/proposal-object-rest-spread/#AbstractOperations-CopyDataProperties
  const params = useCachedParams({ ...useParams(), ...routeParams });

  if (!matches) return null;

  const children = base
    ? (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createElement)(Router, { base }, h_route(renderProps, params))
    : h_route(renderProps, params);

  return (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createElement)(ParamsCtx.Provider, { value: params, children });
};

const Link = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.forwardRef)((props, ref) => {
  const router = useRouter();
  const [currentPath, navigate] = useLocationFromRouter(router);

  const {
    to = "",
    href: targetPath = to,
    onClick: _onClick,
    asChild,
    children,
    className: cls,
    /* eslint-disable no-unused-vars */
    replace /* ignore nav props */,
    state /* ignore nav props */,
    /* eslint-enable no-unused-vars */

    ...restProps
  } = props;

  const onClick = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useEvent)((event) => {
    // ignores the navigation when clicked using right mouse button or
    // by holding a special modifier key: ctrl, command, win, alt, shift
    if (
      event.ctrlKey ||
      event.metaKey ||
      event.altKey ||
      event.shiftKey ||
      event.button !== 0
    )
      return;

    _onClick?.(event);
    if (!event.defaultPrevented) {
      event.preventDefault();
      navigate(targetPath, props);
    }
  });

  // handle nested routers and absolute paths
  const href = router.hrefs(
    targetPath[0] === "~" ? targetPath.slice(1) : router.base + targetPath,
    router // pass router as a second argument for convinience
  );

  return asChild && (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.isValidElement)(children)
    ? (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.cloneElement)(children, { onClick, href })
    : (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.createElement)("a", {
        ...restProps,
        onClick,
        href,
        // `className` can be a function to apply the class if this link is active
        className: cls?.call ? cls(currentPath === targetPath) : cls,
        children,
        ref,
      });
});

const flattenChildren = (children) =>
  Array.isArray(children)
    ? children.flatMap((c) =>
        flattenChildren(c && c.type === _react_deps_js__WEBPACK_IMPORTED_MODULE_2__.Fragment ? c.props.children : c)
      )
    : [children];

const Switch = ({ children, location }) => {
  const router = useRouter();
  const [originalLocation] = useLocationFromRouter(router);

  for (const element of flattenChildren(children)) {
    let match = 0;

    if (
      (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.isValidElement)(element) &&
      // we don't require an element to be of type Route,
      // but we do require it to contain a truthy `path` prop.
      // this allows to use different components that wrap Route
      // inside of a switch, for example <AnimatedRoute />.
      (match = matchRoute(
        router.parser,
        element.props.path,
        location || originalLocation,
        element.props.nest
      ))[0]
    )
      return (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.cloneElement)(element, { match });
  }

  return null;
};

const Redirect = (props) => {
  const { to, href = to } = props;
  const router = useRouter();
  const [, navigate] = useLocationFromRouter(router);
  const redirect = (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useEvent)(() => navigate(to || href, props));
  const { ssrContext } = router;

  // redirect is guaranteed to be stable since it is returned from useEvent
  (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_2__.useIsomorphicLayoutEffect)(() => {
    redirect();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps

  if (ssrContext) {
    ssrContext.redirectTo = to;
  }

  return null;
};




/***/ }),

/***/ "./node_modules/wouter/esm/react-deps.js":
/*!***********************************************!*\
  !*** ./node_modules/wouter/esm/react-deps.js ***!
  \***********************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

var react__WEBPACK_IMPORTED_MODULE_0___namespace_cache;
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Fragment: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.Fragment; },
/* harmony export */   cloneElement: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.cloneElement; },
/* harmony export */   createContext: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.createContext; },
/* harmony export */   createElement: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.createElement; },
/* harmony export */   forwardRef: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.forwardRef; },
/* harmony export */   isValidElement: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.isValidElement; },
/* harmony export */   useContext: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.useContext; },
/* harmony export */   useEvent: function() { return /* binding */ useEvent; },
/* harmony export */   useInsertionEffect: function() { return /* binding */ useInsertionEffect; },
/* harmony export */   useIsomorphicLayoutEffect: function() { return /* binding */ useIsomorphicLayoutEffect; },
/* harmony export */   useMemo: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.useMemo; },
/* harmony export */   useRef: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.useRef; },
/* harmony export */   useState: function() { return /* reexport safe */ react__WEBPACK_IMPORTED_MODULE_0__.useState; },
/* harmony export */   useSyncExternalStore: function() { return /* reexport safe */ use_sync_external_store_shim_index_js__WEBPACK_IMPORTED_MODULE_1__.useSyncExternalStore; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var use_sync_external_store_shim_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! use-sync-external-store/shim/index.js */ "./node_modules/use-sync-external-store/shim/index.js");




// React.useInsertionEffect is not available in React <18
// This hack fixes a transpilation issue on some apps
const useBuiltinInsertionEffect = /*#__PURE__*/ (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache || (react__WEBPACK_IMPORTED_MODULE_0___namespace_cache = __webpack_require__.t(react__WEBPACK_IMPORTED_MODULE_0__, 2)))["useInsertion" + "Effect"];

// Copied from:
// https://github.com/facebook/react/blob/main/packages/shared/ExecutionEnvironment.js
const canUseDOM = !!(
  typeof window !== "undefined" &&
  typeof window.document !== "undefined" &&
  typeof window.document.createElement !== "undefined"
);

// Copied from:
// https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.ts
// "React currently throws a warning when using useLayoutEffect on the server.
// To get around it, we can conditionally useEffect on the server (no-op) and
// useLayoutEffect in the browser."
const useIsomorphicLayoutEffect = canUseDOM
  ? react__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect
  : react__WEBPACK_IMPORTED_MODULE_0__.useEffect;

// useInsertionEffect is already a noop on the server.
// See: https://github.com/facebook/react/blob/main/packages/react-server/src/ReactFizzHooks.js
const useInsertionEffect =
  useBuiltinInsertionEffect || useIsomorphicLayoutEffect;

// Userland polyfill while we wait for the forthcoming
// https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md
// Note: "A high-fidelity polyfill for useEvent is not possible because
// there is no lifecycle or Hook in React that we can use to switch
// .current at the right timing."
// So we will have to make do with this "close enough" approach for now.
const useEvent = (fn) => {
  const ref = react__WEBPACK_IMPORTED_MODULE_0__.useRef([fn, (...args) => ref[0](...args)]).current;
  // Per Dan Abramov: useInsertionEffect executes marginally closer to the
  // correct timing for ref synchronization than useLayoutEffect on React 18.
  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
  useInsertionEffect(() => {
    ref[0] = fn;
  });
  return ref[1];
};




/***/ }),

/***/ "./node_modules/wouter/esm/use-browser-location.js":
/*!*********************************************************!*\
  !*** ./node_modules/wouter/esm/use-browser-location.js ***!
  \*********************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   navigate: function() { return /* binding */ navigate; },
/* harmony export */   useBrowserLocation: function() { return /* binding */ useBrowserLocation; },
/* harmony export */   useHistoryState: function() { return /* binding */ useHistoryState; },
/* harmony export */   useLocationProperty: function() { return /* binding */ useLocationProperty; },
/* harmony export */   usePathname: function() { return /* binding */ usePathname; },
/* harmony export */   useSearch: function() { return /* binding */ useSearch; }
/* harmony export */ });
/* harmony import */ var _react_deps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./react-deps.js */ "./node_modules/wouter/esm/react-deps.js");


/**
 * History API docs @see https://developer.mozilla.org/en-US/docs/Web/API/History
 */
const eventPopstate = "popstate";
const eventPushState = "pushState";
const eventReplaceState = "replaceState";
const eventHashchange = "hashchange";
const events = [
  eventPopstate,
  eventPushState,
  eventReplaceState,
  eventHashchange,
];

const subscribeToLocationUpdates = (callback) => {
  for (const event of events) {
    addEventListener(event, callback);
  }
  return () => {
    for (const event of events) {
      removeEventListener(event, callback);
    }
  };
};

const useLocationProperty = (fn, ssrFn) =>
  (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_0__.useSyncExternalStore)(subscribeToLocationUpdates, fn, ssrFn);

const currentSearch = () => location.search;

const useSearch = ({ ssrSearch = "" } = {}) =>
  useLocationProperty(currentSearch, () => ssrSearch);

const currentPathname = () => location.pathname;

const usePathname = ({ ssrPath } = {}) =>
  useLocationProperty(
    currentPathname,
    ssrPath ? () => ssrPath : currentPathname
  );

const currentHistoryState = () => history.state;
const useHistoryState = () =>
  useLocationProperty(currentHistoryState, () => null);

const navigate = (to, { replace = false, state = null } = {}) =>
  history[replace ? eventReplaceState : eventPushState](state, "", to);

// the 2nd argument of the `useBrowserLocation` return value is a function
// that allows to perform a navigation.
const useBrowserLocation = (opts = {}) => [usePathname(opts), navigate];

const patchKey = Symbol.for("wouter_v3");

// While History API does have `popstate` event, the only
// proper way to listen to changes via `push/replaceState`
// is to monkey-patch these methods.
//
// See https://stackoverflow.com/a/4585031
if (typeof history !== "undefined" && typeof window[patchKey] === "undefined") {
  for (const type of [eventPushState, eventReplaceState]) {
    const original = history[type];
    // TODO: we should be using unstable_batchedUpdates to avoid multiple re-renders,
    // however that will require an additional peer dependency on react-dom.
    // See: https://github.com/reactwg/react-18/discussions/86#discussioncomment-1567149
    history[type] = function () {
      const result = original.apply(this, arguments);
      const event = new Event(type);
      event.arguments = arguments;

      dispatchEvent(event);
      return result;
    };
  }

  // patch history object only once
  // See: https://github.com/molefrog/wouter/issues/167
  Object.defineProperty(window, patchKey, { value: true });
}




/***/ }),

/***/ "./node_modules/wouter/esm/use-hash-location.js":
/*!******************************************************!*\
  !*** ./node_modules/wouter/esm/use-hash-location.js ***!
  \******************************************************/
/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   navigate: function() { return /* binding */ navigate; },
/* harmony export */   useHashLocation: function() { return /* binding */ useHashLocation; }
/* harmony export */ });
/* harmony import */ var _react_deps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./react-deps.js */ "./node_modules/wouter/esm/react-deps.js");


// array of callback subscribed to hash updates
const listeners = {
  v: [],
};

const onHashChange = () => listeners.v.forEach((cb) => cb());

// we subscribe to `hashchange` only once when needed to guarantee that
// all listeners are called synchronously
const subscribeToHashUpdates = (callback) => {
  if (listeners.v.push(callback) === 1)
    addEventListener("hashchange", onHashChange);

  return () => {
    listeners.v = listeners.v.filter((i) => i !== callback);
    if (!listeners.v.length) removeEventListener("hashchange", onHashChange);
  };
};

// leading '#' is ignored, leading '/' is optional
const currentHashLocation = () => "/" + location.hash.replace(/^#?\/?/, "");

const navigate = (to, { state = null, replace = false } = {}) => {
  const [hash, search] = to.replace(/^#?\/?/, "").split("?");

  const newRelativePath =
    location.pathname + (search ? `?${search}` : location.search) + `#/${hash}`;
  const oldURL = location.href;
  const newURL = new URL(newRelativePath, location.origin).href;

  if (replace) {
    history.replaceState(state, "", newRelativePath);
  } else {
    history.pushState(state, "", newRelativePath);
  }

  const event =
    typeof HashChangeEvent !== "undefined"
      ? new HashChangeEvent("hashchange", { oldURL, newURL })
      : new Event("hashchange", { detail: { oldURL, newURL } });

  dispatchEvent(event);
};

const useHashLocation = ({ ssrPath = "/" } = {}) => [
  (0,_react_deps_js__WEBPACK_IMPORTED_MODULE_0__.useSyncExternalStore)(
    subscribeToHashUpdates,
    currentHashLocation,
    () => ssrPath
  ),
  navigate,
];

useHashLocation.hrefs = (href) => "#" + href;




/***/ }),

/***/ "./src/admin/components/global-tabs/component.tsx":
/*!********************************************************!*\
  !*** ./src/admin/components/global-tabs/component.tsx ***!
  \********************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabs: function() { return /* binding */ GlobalTabs; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/ArrowPathIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/ArrowUturnLeftIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/CheckIcon.js");
/* harmony import */ var _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @redfoxwp/core-components/components/button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @redfoxwp/core-components/components/card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @redfoxwp/core-components/components/modal */ "../../../../redfox-packages/core-components/src/components/modal/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_tab_header__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @redfoxwp/core-components/components/tab-header */ "../../../../redfox-packages/core-components/src/components/tab-header/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_11___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_11__);
/* harmony import */ var _contexts__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../../contexts */ "./src/admin/contexts/index.ts");
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../../utils */ "./src/admin/utils/index.ts");
/* harmony import */ var _components_global_tabs_manager__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./components/global-tabs-manager */ "./src/admin/components/global-tabs/components/global-tabs-manager/index.ts");

/**
 * Global Tabs Component
 *
 * Manages global tab settings and configuration.
 *
 * @since 1.0.0
 */












/**
 * Global Tabs content component
 *
 * @since 1.0.0
 *
 * @return JSX element.
 */
const GlobalTabsContent = () => {
    const { isSaving, hasUnsavedChanges, saveTabs, resetTabs, resetToDefaults } = (0,_contexts__WEBPACK_IMPORTED_MODULE_12__.useGlobalTabsContext)();
    // Modal state
    const [showResetModal, setShowResetModal] = (0,react__WEBPACK_IMPORTED_MODULE_11__.useState)(false);
    const [showResetToDefaultsModal, setShowResetToDefaultsModal] = (0,react__WEBPACK_IMPORTED_MODULE_11__.useState)(false);
    const handleSave = async () => {
        await saveTabs();
    };
    const handleReset = () => {
        setShowResetModal(true);
    };
    const handleResetToDefaults = () => {
        setShowResetToDefaultsModal(true);
    };
    const confirmReset = () => {
        resetTabs();
        setShowResetModal(false);
    };
    const confirmResetToDefaults = async () => {
        await resetToDefaults();
        setShowResetToDefaultsModal(false);
    };
    // Sync unsaved changes state with global navigation guard
    (0,react__WEBPACK_IMPORTED_MODULE_11__.useEffect)(() => {
        (0,_utils__WEBPACK_IMPORTED_MODULE_13__.setUnsavedChanges)(hasUnsavedChanges);
    }, [hasUnsavedChanges]);
    // Clean up navigation guard when component unmounts
    (0,react__WEBPACK_IMPORTED_MODULE_11__.useEffect)(() => {
        return () => {
            (0,_utils__WEBPACK_IMPORTED_MODULE_13__.setUnsavedChanges)(false);
        };
    }, []);
    // Browser warning when leaving WordPress admin entirely (not for route changes)
    (0,react__WEBPACK_IMPORTED_MODULE_11__.useEffect)(() => {
        const handleBeforeUnload = (event) => {
            if (hasUnsavedChanges) {
                const message = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('You have unsaved changes. Are you sure you want to leave?', 'redfox-tab-manager');
                event.preventDefault();
                event.returnValue = message;
                return message;
            }
            return undefined;
        };
        window.addEventListener('beforeunload', handleBeforeUnload);
        return () => {
            window.removeEventListener('beforeunload', handleBeforeUnload);
        };
    }, [hasUnsavedChanges]);
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__.Flex, { direction: 'column', gap: '30px', fullWidth: true, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_tab_header__WEBPACK_IMPORTED_MODULE_9__.TabHeader, { title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Global Tabs', 'redfox-tab-manager'), description: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Configure global tab settings that apply to all products. You can enable/disable tabs, set their order, and manage default WooCommerce tabs.', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_6__.Card, { styleProps: { padding: '30px', radius: '10px', background: '#fff' }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_components_global_tabs_manager__WEBPACK_IMPORTED_MODULE_14__.GlobalTabsManager, {}) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_6__.Card, { styleProps: { padding: '30px', radius: '10px', background: '#fff' }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__.Flex, { justify: 'space-between', align: 'center', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { onClick: handleResetToDefaults, variant: 'outline', size: 'small', disabled: isSaving, styleProps: {
                                    borderColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors?.gray?.[300],
                                    color: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors?.gray?.[500],
                                    hoverBackgroundColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors?.gray?.[100],
                                    hoverColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors?.gray?.[700],
                                    hoverBorderColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors?.gray?.[300],
                                }, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { style: { width: '16px', height: '16px', marginRight: '8px' } }), (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset to Defaults', 'redfox-tab-manager')] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__.Flex, { gap: '15px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { onClick: handleReset, variant: 'outline', disabled: isSaving || !hasUnsavedChanges, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { style: { width: '16px', height: '16px', marginRight: '8px' } }), (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset Changes', 'redfox-tab-manager')] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { onClick: handleSave, variant: 'solid', disabled: isSaving || !hasUnsavedChanges, children: [!isSaving && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { style: { width: '16px', height: '16px', marginRight: '8px' } })), isSaving ? (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Saving…', 'redfox-tab-manager') : (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Save', 'redfox-tab-manager')] })] })] }) }), (() => {
                    const modalStrings = {
                        closeModal: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Close modal', 'redfox-tab-manager'),
                    };
                    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_8__.Modal, { isOpen: showResetModal, onClose: () => setShowResetModal(false), title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset Changes', 'redfox-tab-manager'), strings: modalStrings, footer: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__.Flex, { justify: 'flex-end', gap: '15px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { variant: 'outline', onClick: () => setShowResetModal(false), children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Cancel', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { variant: 'solid', onClick: confirmReset, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset', 'redfox-tab-manager') })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Are you sure you want to reset all changes? This will restore the tabs to their last saved state.', 'redfox-tab-manager') }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_8__.Modal, { isOpen: showResetToDefaultsModal, onClose: () => setShowResetToDefaultsModal(false), title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset to Defaults', 'redfox-tab-manager'), strings: modalStrings, footer: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_7__.Flex, { justify: 'flex-end', gap: '15px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { variant: 'outline', onClick: () => setShowResetToDefaultsModal(false), children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Cancel', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_5__.Button, { variant: 'solid', onClick: confirmResetToDefaults, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Reset to Defaults', 'redfox-tab-manager') })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_10__.__)('Are you sure you want to reset ALL tabs to default WooCommerce tabs? This will permanently delete all custom tabs and cannot be undone.', 'redfox-tab-manager') }) })] }));
                })()] }) }));
};
/**
 * Global Tabs component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const GlobalTabs = () => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_contexts__WEBPACK_IMPORTED_MODULE_12__.GlobalTabsProvider, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(GlobalTabsContent, {}) }));
};


/***/ }),

/***/ "./src/admin/components/global-tabs/components/global-tabs-manager/component.tsx":
/*!***************************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/global-tabs-manager/component.tsx ***!
  \***************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabsManager: function() { return /* binding */ GlobalTabsManager; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/PlusIcon.js");
/* harmony import */ var _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @redfoxwp/core-components/colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @redfoxwp/core-components/components/button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/components/card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex-item */ "../../../../redfox-packages/core-components/src/components/flex-item/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_loading_spinner__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @redfoxwp/core-components/components/loading-spinner */ "../../../../redfox-packages/core-components/src/components/loading-spinner/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_sortable__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @redfoxwp/core-components/components/sortable */ "../../../../redfox-packages/core-components/src/components/sortable/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_9___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_10___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_10__);
/* harmony import */ var _contexts__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../../../../contexts */ "./src/admin/contexts/index.ts");
/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../../../../hooks */ "./src/admin/hooks/index.ts");
/* harmony import */ var _tab_item_renderer__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../tab-item-renderer */ "./src/admin/components/global-tabs/components/tab-item-renderer/index.ts");
/* harmony import */ var _tab_modal__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ../tab-modal */ "./src/admin/components/global-tabs/components/tab-modal/index.ts");















const GlobalTabsManager = () => {
    const [modalState, setModalState] = (0,react__WEBPACK_IMPORTED_MODULE_10__.useState)({
        isOpen: false,
        mode: 'add',
    });
    // Use context for all state and operations
    const { tabs, loading: isLoading, isSaving, updateTabs, deleteTab } = (0,_contexts__WEBPACK_IMPORTED_MODULE_11__.useGlobalTabsContext)();
    const { showError } = (0,_hooks__WEBPACK_IMPORTED_MODULE_12__.useNotifications)();
    const handleAddNewTab = () => {
        setModalState({
            isOpen: true,
            mode: 'add',
        });
    };
    const handleEditTab = (tab) => {
        // Don't allow editing of WooCommerce default tabs
        if (tab.type === 'woocommerce_default') {
            showError((0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__.__)('WooCommerce default tabs cannot be edited.', 'redfox-tab-manager'));
            return;
        }
        setModalState({
            isOpen: true,
            mode: 'edit',
            editingTab: tab,
        });
    };
    const handleDeleteTab = async (tabId) => {
        await deleteTab(tabId);
    };
    const handleToggleEnabled = (tabId, enabled) => {
        const newTabs = tabs.map((tab) => (tab.id === tabId ? { ...tab, enabled } : tab));
        updateTabs(newTabs);
    };
    const handleReorder = (reorderedTabs) => {
        // Update priorities based on new order using (10 * index) + 10
        const updatedTabs = reorderedTabs.map((tab, index) => ({
            ...tab,
            priority: 10 * index + 10,
        }));
        updateTabs(updatedTabs);
    };
    const handleModalClose = () => {
        setModalState({
            isOpen: false,
            mode: 'add',
        });
    };
    const handleModalSave = (tab) => {
        let newTabs;
        if (modalState.mode === 'edit' && modalState.editingTab) {
            // Update existing tab
            newTabs = tabs.map((existingTab) => existingTab.id === modalState.editingTab?.id ? tab : existingTab);
        }
        else {
            // Add new tab with priority based on position using (10 * index) + 10
            const newTabWithPriority = {
                ...tab,
                priority: 10 * tabs.length + 10,
            };
            newTabs = [...tabs, newTabWithPriority];
        }
        // Update all priorities based on final order using (10 * index) + 10
        const finalTabs = newTabs.map((t, index) => ({
            ...t,
            priority: 10 * index + 10,
        }));
        updateTabs(finalTabs);
        handleModalClose();
    };
    if (isLoading && tabs.length === 0) {
        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_4__.Card, { center: true, styleProps: { padding: '30px' }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_loading_spinner__WEBPACK_IMPORTED_MODULE_7__.LoadingSpinner, {}) }));
    }
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [isSaving && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_loading_spinner__WEBPACK_IMPORTED_MODULE_7__.LoadingSpinner, { isLoading: true, overlay: true, overlayMode: 'absolute', centered: true, variant: 'ring', size: 'large', showText: true, text: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__.__)('Saving tabs…', 'redfox-tab-manager') })), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_5__.Flex, { direction: 'column', gap: '30px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_6__.FlexItem, { children: !Array.isArray(tabs) || tabs.length === 0 ? ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_4__.Card, { center: true, styleProps: {
                                border: `1px dashed ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_2__.colors.gray[200]}`,
                                padding: '30px',
                                radius: '5px',
                            }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__.__)('No global tabs found. Add your first global tab to get started.', 'redfox-tab-manager') }) })) : ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_sortable__WEBPACK_IMPORTED_MODULE_8__.Sortable, { items: tabs, onReorder: handleReorder, renderItem: (tab, _index, isDragging) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_tab_item_renderer__WEBPACK_IMPORTED_MODULE_13__.TabItemRenderer, { tab: tab, isDragging: isDragging, onEdit: handleEditTab, onDelete: handleDeleteTab, onToggleEnabled: handleToggleEnabled })), "aria-label": (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_9__.__)('Global tabs list', 'redfox-tab-manager'), direction: 'vertical' })) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_6__.FlexItem, { alignSelf: 'center', children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_3__.Button, { onClick: handleAddNewTab, disabled: isSaving, size: 'small', variant: 'outline', styleProps: { width: '40px', height: '40px', padding: '0' }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 20, height: 20 }) }) })] }), modalState.isOpen &&
                (() => {
                    if (modalState.mode === 'add') {
                        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_tab_modal__WEBPACK_IMPORTED_MODULE_14__.TabModal, { isOpen: modalState.isOpen, mode: modalState.mode, onClose: handleModalClose, onSave: handleModalSave, onError: (_message) => {
                                // Error is handled by the modal component
                            } }));
                    }
                    if (modalState.editingTab) {
                        return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_tab_modal__WEBPACK_IMPORTED_MODULE_14__.TabModal, { isOpen: modalState.isOpen, mode: modalState.mode, editingTab: modalState.editingTab, onClose: handleModalClose, onSave: handleModalSave, onError: (_message) => {
                                // Error is handled by the modal component
                            } }));
                    }
                    return null;
                })()] }));
};


/***/ }),

/***/ "./src/admin/components/global-tabs/components/global-tabs-manager/index.ts":
/*!**********************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/global-tabs-manager/index.ts ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabsManager: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.GlobalTabsManager; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/global-tabs/components/global-tabs-manager/component.tsx");



/***/ }),

/***/ "./src/admin/components/global-tabs/components/index.ts":
/*!**************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/index.ts ***!
  \**************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabsManager: function() { return /* reexport safe */ _global_tabs_manager__WEBPACK_IMPORTED_MODULE_0__.GlobalTabsManager; },
/* harmony export */   TabItemRenderer: function() { return /* reexport safe */ _tab_item_renderer__WEBPACK_IMPORTED_MODULE_1__.TabItemRenderer; },
/* harmony export */   TabModal: function() { return /* reexport safe */ _tab_modal__WEBPACK_IMPORTED_MODULE_2__.TabModal; }
/* harmony export */ });
/* harmony import */ var _global_tabs_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./global-tabs-manager */ "./src/admin/components/global-tabs/components/global-tabs-manager/index.ts");
/* harmony import */ var _tab_item_renderer__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./tab-item-renderer */ "./src/admin/components/global-tabs/components/tab-item-renderer/index.ts");
/* harmony import */ var _tab_modal__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./tab-modal */ "./src/admin/components/global-tabs/components/tab-modal/index.ts");
/**
 * Global Tabs Components Exports
 *
 * @since 1.0.0
 */





/***/ }),

/***/ "./src/admin/components/global-tabs/components/tab-item-renderer/component.tsx":
/*!*************************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/tab-item-renderer/component.tsx ***!
  \*************************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabItemRenderer: function() { return /* binding */ TabItemRenderer; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/Bars3Icon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/PencilIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/TrashIcon.js");
/* harmony import */ var _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var _redfoxwp_core_components_components_badge__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @redfoxwp/core-components/components/badge */ "../../../../redfox-packages/core-components/src/components/badge/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @redfoxwp/core-components/components/button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! @redfoxwp/core-components/components/card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @redfoxwp/core-components/components/modal */ "../../../../redfox-packages/core-components/src/components/modal/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_sortable__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! @redfoxwp/core-components/components/sortable */ "../../../../redfox-packages/core-components/src/components/sortable/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_toggle__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! @redfoxwp/core-components/components/toggle */ "../../../../redfox-packages/core-components/src/components/toggle/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_12___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_13___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_13__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./styled */ "./src/admin/components/global-tabs/components/tab-item-renderer/styled.tsx");













const actionButtonStyleProps = {
    backgroundColor: 'transparent',
    color: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.gray[800],
    borderWidth: '0',
    borderRadius: '5px',
    width: '32px',
    height: '32px',
    padding: '0',
    hoverBoxShadow: `0px 4px 10px ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[100]}`,
    hoverBackgroundColor: 'transparent',
    hoverColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[300],
};
const deleteButtonStyleProps = {
    ...actionButtonStyleProps,
    hoverColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.error,
};
const TabItemRenderer = ({ tab, isDragging, onEdit, onDelete, onToggleEnabled, }) => {
    const [showDeleteModal, setShowDeleteModal] = (0,react__WEBPACK_IMPORTED_MODULE_13__.useState)(false);
    const handleEdit = () => {
        onEdit(tab);
    };
    const handleDeleteClick = () => {
        setShowDeleteModal(true);
    };
    const handleDeleteConfirm = () => {
        onDelete(tab.id);
        setShowDeleteModal(false);
    };
    const handleDeleteCancel = () => {
        setShowDeleteModal(false);
    };
    const handleToggleEnabled = (checked) => {
        onToggleEnabled(tab.id, checked);
    };
    // Create localized strings for the modal
    const modalStrings = {
        closeModal: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Close modal', 'redfox-tab-manager'),
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_7__.Card, { styleProps: {
                    padding: '10px',
                    radius: '5px',
                    background: '#fff',
                    border: `1px solid ${isDragging ? _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[100] : _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.gray[100]}`,
                }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__.Flex, { direction: 'row', justify: 'space-between', align: 'center', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__.Flex, { direction: 'row', align: 'center', gap: '10px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_sortable__WEBPACK_IMPORTED_MODULE_10__.DragHandle, { title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Drag to reorder', 'redfox-tab-manager'), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 24, height: 24 }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__.Flex, { direction: 'row', gap: '10px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_14__.StyledTabTitle, { children: tab.title }), tab.type && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_badge__WEBPACK_IMPORTED_MODULE_5__.Badge, { size: 'small', variant: 'solid', styleProps: (() => {
                                                const baseStyle = {
                                                    fontSize: '11px',
                                                    fontWeight: '500',
                                                    padding: '2px 8px',
                                                    borderRadius: '12px',
                                                };
                                                if (tab.type === 'woocommerce_default') {
                                                    return {
                                                        ...baseStyle,
                                                        backgroundColor: '#eee3ff',
                                                        color: '#873eff',
                                                        borderColor: '#d0b2ff',
                                                    };
                                                }
                                                else if (tab.type === 'redfoxwp_tab') {
                                                    return {
                                                        ...baseStyle,
                                                        backgroundColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[50],
                                                        color: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[300],
                                                        borderColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[100],
                                                    };
                                                }
                                                else {
                                                    return {
                                                        ...baseStyle,
                                                        backgroundColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.gray[100],
                                                        color: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.gray[600],
                                                        borderColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.gray[200],
                                                    };
                                                }
                                            })(), children: (() => {
                                                if (tab.type === 'woocommerce_default') {
                                                    return 'WooCommerce';
                                                }
                                                else if (tab.type === 'redfoxwp_tab') {
                                                    return 'RedFox WP';
                                                }
                                                return 'Custom';
                                            })() }))] })] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__.Flex, { direction: 'row', align: 'center', gap: '10px', children: [tab.type !== 'woocommerce_default' && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_toggle__WEBPACK_IMPORTED_MODULE_11__.Toggle, { checked: tab.enabled, onChange: handleToggleEnabled, size: 'small' })), tab.type !== 'woocommerce_default' && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_6__.Button, { variant: 'ghost', onClick: handleEdit, styleProps: actionButtonStyleProps, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 16, height: 16 }) })), tab.type !== 'woocommerce_default' && ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_6__.Button, { variant: 'ghost', onClick: handleDeleteClick, styleProps: deleteButtonStyleProps, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_3__["default"], { width: 16, height: 16 }) }))] })] }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_9__.Modal, { isOpen: showDeleteModal, onClose: handleDeleteCancel, title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Confirm Delete', 'redfox-tab-manager'), strings: modalStrings, styleProps: {
                    maxWidth: '400px',
                    borderRadius: '8px',
                }, footer: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_8__.Flex, { gap: '12px', justify: 'flex-end', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_6__.Button, { variant: 'outline', onClick: handleDeleteCancel, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Cancel', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_6__.Button, { variant: 'solid', onClick: handleDeleteConfirm, styleProps: {
                                backgroundColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.error,
                                hoverBackgroundColor: _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_4__.colors.primary[600],
                                color: '#fff',
                            }, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Delete', 'redfox-tab-manager') })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { style: { margin: '0 0 16px 0', fontSize: '14px', lineHeight: '1.5', color: '#1e1e1e' }, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_12__.__)('Are you sure you want to delete this tab? This action cannot be undone.', 'redfox-tab-manager') }) })] }));
};


/***/ }),

/***/ "./src/admin/components/global-tabs/components/tab-item-renderer/index.ts":
/*!********************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/tab-item-renderer/index.ts ***!
  \********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledActionButton: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledActionButton; },
/* harmony export */   StyledTabActions: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledTabActions; },
/* harmony export */   StyledTabHeader: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledTabHeader; },
/* harmony export */   StyledTabItem: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledTabItem; },
/* harmony export */   StyledTabTitle: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledTabTitle; },
/* harmony export */   StyledToggleWrapper: function() { return /* reexport safe */ _styled__WEBPACK_IMPORTED_MODULE_1__.StyledToggleWrapper; },
/* harmony export */   TabItemRenderer: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.TabItemRenderer; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/global-tabs/components/tab-item-renderer/component.tsx");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./styled */ "./src/admin/components/global-tabs/components/tab-item-renderer/styled.tsx");




/***/ }),

/***/ "./src/admin/components/global-tabs/components/tab-item-renderer/styled.tsx":
/*!**********************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/tab-item-renderer/styled.tsx ***!
  \**********************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   StyledActionButton: function() { return /* binding */ StyledActionButton; },
/* harmony export */   StyledTabActions: function() { return /* binding */ StyledTabActions; },
/* harmony export */   StyledTabHeader: function() { return /* binding */ StyledTabHeader; },
/* harmony export */   StyledTabItem: function() { return /* binding */ StyledTabItem; },
/* harmony export */   StyledTabTitle: function() { return /* binding */ StyledTabTitle; },
/* harmony export */   StyledToggleWrapper: function() { return /* binding */ StyledToggleWrapper; }
/* harmony export */ });
/* harmony import */ var _emotion_react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react */ "./node_modules/@emotion/react/dist/emotion-react.browser.development.esm.js");
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @emotion/styled */ "./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");


const StyledTabItem = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  position: relative;

  /* Disabled state */
  ${({ $isDisabled }) => $isDisabled &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.6;
      background: #f9f9f9;
      border-color: #e1e1e1;
    `}

  /* Dragging state */
  ${({ $isDragging }) => $isDragging &&
    (0,_emotion_react__WEBPACK_IMPORTED_MODULE_0__.css) `
      opacity: 0.8;
      transform: rotate(2deg);
      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
      border-color: #007cba;
      z-index: 1000;
    `}
`;
const StyledTabHeader = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  align-items: center;
  gap: 12px;
  padding: 16px;
  min-height: 60px;
`;
const StyledTabTitle = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].span `
  display: block;
  font-size: 16px;
  font-weight: 500;
  color: #1e1e1e;
  margin-bottom: 4px;
  line-height: 1.4;
`;
const StyledTabActions = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  align-items: center;
  gap: 8px;
`;
const StyledToggleWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  display: flex;
  align-items: center;

  /* Reset any default margins for toggle components */
  > * {
    margin: 0;
  }
`;
const StyledActionButton = _emotion_styled__WEBPACK_IMPORTED_MODULE_1__["default"].div `
  .components-button {
    width: 36px;
    height: 36px;
    min-width: 36px;
    padding: 0;
    display: flex;
    align-items: center;
    justify-content: center;
    border-radius: 4px;
    transition: all 0.2s ease;

    &.redfox-global-tab-item__edit-btn {
      border-color: #007cba;
      color: #007cba;

      &:hover {
        background: #007cba;
        color: #fff;
      }
    }

    &.redfox-global-tab-item__delete-btn {
      border-color: #d63638;
      color: #d63638;

      &:hover {
        background: #d63638;
        color: #fff;
      }
    }
  }
`;


/***/ }),

/***/ "./src/admin/components/global-tabs/components/tab-modal/component.tsx":
/*!*****************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/tab-modal/component.tsx ***!
  \*****************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabModal: function() { return /* binding */ TabModal; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/components/button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex-item */ "../../../../redfox-packages/core-components/src/components/flex-item/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/components/modal */ "../../../../redfox-packages/core-components/src/components/modal/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_select__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @redfoxwp/core-components/components/select */ "../../../../redfox-packages/core-components/src/components/select/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var _admin_contexts__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! @/admin/contexts */ "./src/admin/contexts/index.ts");
/* harmony import */ var _admin_hooks_use_global_tabs__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! @/admin/hooks/use-global-tabs */ "./src/admin/hooks/use-global-tabs/index.ts");










const TabModal = ({ isOpen, mode, editingTab, onClose, onSave, onError, }) => {
    const [formData, setFormData] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)({
        title: '',
        content: '',
        priority: 10,
        enabled: true,
        type: 'redfoxwp_tab',
        source: 'redfox',
        redfoxwp_tab_id: 0,
    });
    const [redFoxTabs, setRedFoxTabs] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)([]);
    const [isLoadingTabs, setIsLoadingTabs] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)(false);
    // Use the global tabs hook for fetching RedFox tabs
    const { fetchRedFoxTabs } = (0,_admin_hooks_use_global_tabs__WEBPACK_IMPORTED_MODULE_9__.useGlobalTabs)({
        autoLoad: false, // Don't auto-load global tabs, we only need the fetchRedFoxTabs method
        ...(onError && { onError }),
    });
    // Get current global tabs from context to filter out duplicates
    const { tabs: globalTabs } = (0,_admin_contexts__WEBPACK_IMPORTED_MODULE_8__.useGlobalTabsContext)();
    const loadRedFoxTabs = react__WEBPACK_IMPORTED_MODULE_7___default().useCallback(async () => {
        setIsLoadingTabs(true);
        try {
            const tabsData = await fetchRedFoxTabs({
                postsPerPage: -1,
                orderBy: 'date',
                order: 'DESC',
            });
            setRedFoxTabs(tabsData);
        }
        catch {
            setRedFoxTabs([]); // Set empty array on error
            // Error handling is already done in the hook
        }
        setIsLoadingTabs(false);
    }, [fetchRedFoxTabs]);
    (0,react__WEBPACK_IMPORTED_MODULE_7__.useEffect)(() => {
        if (isOpen) {
            if (mode === 'edit' && editingTab) {
                setFormData(editingTab);
            }
            else {
                // Reset form for new tab
                setFormData({
                    title: '',
                    content: '',
                    priority: 10,
                    enabled: true,
                    type: 'redfoxwp_tab',
                    source: 'redfox',
                    redfoxwp_tab_id: 0,
                });
            }
            // Load RedFox tabs
            loadRedFoxTabs();
        }
    }, [isOpen, mode, editingTab, loadRedFoxTabs]);
    // Filter out already added tabs (except when editing the current tab)
    const availableRedFoxTabs = react__WEBPACK_IMPORTED_MODULE_7___default().useMemo(() => {
        // Get list of already added RedFox tab IDs
        const addedTabIds = globalTabs
            .filter((tab) => tab.type === 'redfoxwp_tab' && tab.redfoxwp_tab_id)
            .map((tab) => tab.redfoxwp_tab_id);
        // When editing, allow the current tab's ID to be available
        const currentEditingTabId = mode === 'edit' && editingTab?.redfoxwp_tab_id ? editingTab.redfoxwp_tab_id : null;
        return redFoxTabs.filter((tab) => {
            // Include if not already added, or if it's the currently editing tab
            return !addedTabIds.includes(tab.id) || tab.id === currentEditingTabId;
        });
    }, [redFoxTabs, globalTabs, mode, editingTab]);
    // Convert available RedFox tabs to Select options
    const selectOptions = react__WEBPACK_IMPORTED_MODULE_7___default().useMemo(() => availableRedFoxTabs.map((tab) => ({
        value: tab.id.toString(),
        label: tab.title,
    })), [availableRedFoxTabs]);
    const handleRedFoxTabChange = (value, _selectedOptions) => {
        // Since we're using single select mode, value should be a string
        const selectedValue = Array.isArray(value) ? value[0] : value;
        const tabId = parseInt(selectedValue ?? '', 10);
        const selectedTab = availableRedFoxTabs.find((tab) => tab.id === tabId);
        setFormData((prev) => ({
            ...prev,
            redfoxwp_tab_id: tabId,
            title: selectedTab ? selectedTab.title : (prev.title ?? ''),
            content: selectedTab ? selectedTab.content : '',
        }));
    };
    const handleSave = () => {
        // Validate that a RedFox tab is selected
        if (!formData.redfoxwp_tab_id || formData.redfoxwp_tab_id === 0) {
            onError?.((0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Please select a RedFox tab', 'redfox-tab-manager'));
            return;
        }
        // Get the selected RedFox tab data
        const selectedRedFoxTab = availableRedFoxTabs.find((tab) => tab.id === formData.redfoxwp_tab_id);
        const newTab = {
            id: formData.id ?? `tab_${Date.now()}`,
            title: selectedRedFoxTab ? selectedRedFoxTab.title : (formData.title ?? 'RedFox Tab'),
            content: selectedRedFoxTab ? selectedRedFoxTab.content : (formData.content ?? ''),
            priority: formData.priority ?? 10,
            enabled: formData.enabled !== false,
            type: 'redfoxwp_tab',
            source: 'redfox',
            redfoxwp_tab_id: formData.redfoxwp_tab_id ?? 0,
        };
        onSave(newTab);
    };
    // Dynamic button text based on mode
    const buttonText = mode === 'edit' ? (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Save Changes', 'redfox-tab-manager') : (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Add', 'redfox-tab-manager');
    // Check if a tab is selected for button state
    const isTabSelected = formData.redfoxwp_tab_id && formData.redfoxwp_tab_id !== 0;
    // Footer with action button
    const footer = ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_1__.Button, { onClick: handleSave, variant: 'solid', size: 'medium', disabled: !isTabSelected, children: buttonText }));
    // Create localized strings for the modal
    const modalStrings = {
        closeModal: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Close modal', 'redfox-tab-manager'),
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_4__.Modal, { isOpen: isOpen, title: mode === 'edit' ? (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Edit Tab', 'redfox-tab-manager') : (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Add Tab', 'redfox-tab-manager'), onClose: onClose, footer: footer, strings: modalStrings, styleProps: {
            overflow: 'visible', // Allow dropdowns to overflow the modal
        }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_2__.Flex, { direction: 'column', gap: '10px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_3__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("label", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Select a tab', 'redfox-tab-manager') }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_flex_item__WEBPACK_IMPORTED_MODULE_3__.FlexItem, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_select__WEBPACK_IMPORTED_MODULE_5__.Select, { options: selectOptions, value: formData.redfoxwp_tab_id ? formData.redfoxwp_tab_id.toString() : '', onChange: handleRedFoxTabChange, placeholder: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Select a RedFox Tab…', 'redfox-tab-manager'), searchable: true, clearable: true, disabled: isLoadingTabs, noOptionsText: (() => {
                            if (isLoadingTabs) {
                                return (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Loading RedFox tabs…', 'redfox-tab-manager');
                            }
                            if (redFoxTabs.length === 0) {
                                return (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('No RedFox tabs available.', 'redfox-tab-manager');
                            }
                            return (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('All RedFox tabs have already been added.', 'redfox-tab-manager');
                        })(), size: 'medium', styleProps: {
                            zIndex: 99999999, // Higher than modal z-index (9999999) + backdrop safety margin
                            maxHeight: '400px', // Increase max height
                        } }) })] }) }));
};


/***/ }),

/***/ "./src/admin/components/global-tabs/components/tab-modal/index.ts":
/*!************************************************************************!*\
  !*** ./src/admin/components/global-tabs/components/tab-modal/index.ts ***!
  \************************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabModal: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.TabModal; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/global-tabs/components/tab-modal/component.tsx");



/***/ }),

/***/ "./src/admin/components/global-tabs/index.ts":
/*!***************************************************!*\
  !*** ./src/admin/components/global-tabs/index.ts ***!
  \***************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabs: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.GlobalTabs; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/global-tabs/component.tsx");
/**
 * Global Tabs Component Exports
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/components/index.ts":
/*!***************************************!*\
  !*** ./src/admin/components/index.ts ***!
  \***************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabs: function() { return /* reexport safe */ _global_tabs__WEBPACK_IMPORTED_MODULE_0__.GlobalTabs; },
/* harmony export */   GlobalTabsManager: function() { return /* reexport safe */ _global_tabs_components__WEBPACK_IMPORTED_MODULE_6__.GlobalTabsManager; },
/* harmony export */   Navigation: function() { return /* reexport safe */ _navigation__WEBPACK_IMPORTED_MODULE_1__.Navigation; },
/* harmony export */   NotificationsContainer: function() { return /* reexport safe */ _notifications_container__WEBPACK_IMPORTED_MODULE_2__.NotificationsContainer; },
/* harmony export */   SidebarFooter: function() { return /* reexport safe */ _sidebar_footer__WEBPACK_IMPORTED_MODULE_3__.SidebarFooter; },
/* harmony export */   TabItemRenderer: function() { return /* reexport safe */ _global_tabs_components__WEBPACK_IMPORTED_MODULE_6__.TabItemRenderer; },
/* harmony export */   TabList: function() { return /* reexport safe */ _tab_list__WEBPACK_IMPORTED_MODULE_4__.TabList; },
/* harmony export */   TabManagerApp: function() { return /* reexport safe */ _tab_manager_app__WEBPACK_IMPORTED_MODULE_5__.TabManagerApp; },
/* harmony export */   TabModal: function() { return /* reexport safe */ _global_tabs_components__WEBPACK_IMPORTED_MODULE_6__.TabModal; }
/* harmony export */ });
/* harmony import */ var _global_tabs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./global-tabs */ "./src/admin/components/global-tabs/index.ts");
/* harmony import */ var _navigation__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./navigation */ "./src/admin/components/navigation/index.ts");
/* harmony import */ var _notifications_container__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./notifications-container */ "./src/admin/components/notifications-container/index.ts");
/* harmony import */ var _sidebar_footer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./sidebar-footer */ "./src/admin/components/sidebar-footer/index.ts");
/* harmony import */ var _tab_list__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./tab-list */ "./src/admin/components/tab-list/index.ts");
/* harmony import */ var _tab_manager_app__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./tab-manager-app */ "./src/admin/components/tab-manager-app/index.ts");
/* harmony import */ var _global_tabs_components__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./global-tabs/components */ "./src/admin/components/global-tabs/components/index.ts");
/**
 * Admin Components Exports
 *
 * @since 1.0.0
 */






// Re-export global-tabs components



/***/ }),

/***/ "./src/admin/components/navigation/component.tsx":
/*!*******************************************************!*\
  !*** ./src/admin/components/navigation/component.tsx ***!
  \*******************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Navigation: function() { return /* binding */ Navigation; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/GlobeAltIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/QueueListIcon.js");
/* harmony import */ var _redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @redfoxwp/core-components/components/button */ "../../../../redfox-packages/core-components/src/components/button/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @redfoxwp/core-components/components/modal */ "../../../../redfox-packages/core-components/src/components/modal/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var wouter_use_hash_location__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! wouter/use-hash-location */ "./node_modules/wouter/esm/use-hash-location.js");
/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../../hooks */ "./src/admin/hooks/index.ts");
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./styled */ "./src/admin/components/navigation/styled.tsx");

/**
 * Navigation Component
 *
 * Sidebar navigation for the Tab Manager admin interface.
 *
 * @since 1.0.0
 */









/**
 * Protected Navigation Item component that checks for unsaved changes
 *
 * @since 1.0.0
 */
const ProtectedNavigationItem = ({ path, label, description, icon, }) => {
    const [location, setLocation] = (0,wouter_use_hash_location__WEBPACK_IMPORTED_MODULE_8__.useHashLocation)();
    const { hasUnsavedChanges } = (0,_hooks__WEBPACK_IMPORTED_MODULE_9__.useNavigationGuard)();
    const [showConfirmModal, setShowConfirmModal] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)(false);
    const [pendingPath, setPendingPath] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)(null);
    const isActive = location === path;
    const handleClick = (event) => {
        // If we're already on this path, don't do anything
        if (location === path) {
            return;
        }
        // Only show confirmation modal if:
        // 1. There are unsaved changes AND
        // 2. User is currently on the global-tabs page (leaving global tabs)
        if (hasUnsavedChanges && location === '/global-tabs') {
            event.preventDefault();
            setPendingPath(path);
            setShowConfirmModal(true);
        }
    };
    const handleConfirmNavigation = () => {
        if (pendingPath) {
            setLocation(pendingPath);
            setPendingPath(null);
        }
        setShowConfirmModal(false);
    };
    const handleCancelNavigation = () => {
        setPendingPath(null);
        setShowConfirmModal(false);
    };
    // Create localized strings for the modal
    const modalStrings = {
        closeModal: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Close modal', 'redfox-tab-manager'),
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.Fragment, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_10__.NavigationItem, { to: path, title: description, onClick: handleClick, "$isActive": isActive, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_10__.NavigationItemIcon, { children: icon }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_10__.NavigationItemLabel, { children: label })] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_modal__WEBPACK_IMPORTED_MODULE_5__.Modal, { isOpen: showConfirmModal, onClose: handleCancelNavigation, title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Unsaved Changes', 'redfox-tab-manager'), strings: modalStrings, footer: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_4__.Flex, { gap: '10px', justify: 'flex-end', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_3__.Button, { variant: 'outline', onClick: handleCancelNavigation, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Cancel', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_button__WEBPACK_IMPORTED_MODULE_3__.Button, { variant: 'solid', onClick: handleConfirmNavigation, children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Leave Page', 'redfox-tab-manager') })] }), children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("p", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('You have unsaved changes in Global Tabs. If you leave now, your changes will be lost. Are you sure you want to continue?', 'redfox-tab-manager') }) })] }));
};
/**
 * Navigation component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const Navigation = () => {
    const navigationItems = [
        {
            path: '/tabs',
            label: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Tab List', 'redfox-tab-manager'),
            description: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Manage individual tabs', 'redfox-tab-manager'),
            icon: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 20, height: 20 }),
        },
        {
            path: '/global-tabs',
            label: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Global Tabs', 'redfox-tab-manager'),
            description: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_6__.__)('Configure global tab settings', 'redfox-tab-manager'),
            icon: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 20, height: 20 }),
        },
    ];
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_10__.NavigationMenu, { children: navigationItems.map((item) => ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(ProtectedNavigationItem, { path: item.path, label: item.label, description: item.description, icon: item.icon }, item.path))) }));
};


/***/ }),

/***/ "./src/admin/components/navigation/index.ts":
/*!**************************************************!*\
  !*** ./src/admin/components/navigation/index.ts ***!
  \**************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Navigation: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.Navigation; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/navigation/component.tsx");
/**
 * Navigation Component Exports
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/components/navigation/styled.tsx":
/*!****************************************************!*\
  !*** ./src/admin/components/navigation/styled.tsx ***!
  \****************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NavigationItem: function() { return /* binding */ NavigationItem; },
/* harmony export */   NavigationItemIcon: function() { return /* binding */ NavigationItemIcon; },
/* harmony export */   NavigationItemLabel: function() { return /* binding */ NavigationItemLabel; },
/* harmony export */   NavigationMenu: function() { return /* binding */ NavigationMenu; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/* harmony import */ var wouter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! wouter */ "./node_modules/wouter/esm/index.js");
/**
 * Navigation Component Styled Components
 *
 * @since 1.0.0
 */



const NavigationMenu = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
  display: flex;
  flex-direction: column;
  flex: 1;
`;
const NavigationItem = (0,_emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"])((0,wouter__WEBPACK_IMPORTED_MODULE_2__.Link), {
    shouldForwardProp: (prop) => prop !== '$isActive',
}) `
  display: flex;
  align-items: center;
  gap: 12px;
  padding: 15px 30px;
  color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[800]};
  text-decoration: none;
  font-size: 1.2em;
  font-weight: 400;
  transition: all 0.2s ease;
  border-top: 1px solid ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[100]};
  position: relative;
  box-shadow: none !important;

  &:hover {
    color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
  }

  &:focus,
  &:active {
    color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
    box-shadow: 4px 0 0 0 ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]} inset !important;
    background-color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[50]};
  }

  ${(props) => props.$isActive &&
    `
    color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
    box-shadow: 4px 0 0 0 ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]} inset !important;
    background-color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[50]};
  `}
`;
const NavigationItemIcon = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  font-size: 1.2em;
  line-height: 1;
  flex-shrink: 0;
`;
const NavigationItemLabel = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].span `
  flex: 1;
`;


/***/ }),

/***/ "./src/admin/components/notifications-container/component.tsx":
/*!********************************************************************!*\
  !*** ./src/admin/components/notifications-container/component.tsx ***!
  \********************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationsContainer: function() { return /* binding */ NotificationsContainer; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_components_notifications_container__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/components/notifications-container */ "../../../../redfox-packages/core-components/src/components/notifications-container/index.ts");
/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../hooks */ "./src/admin/hooks/index.ts");

/**
 * Notifications Container Component
 *
 * Wrapper around @redfoxwp/core-components NotificationsContainer
 * that integrates with the application's notification context.
 *
 * @since 1.0.0
 */


/**
 * Notifications Container component
 *
 * Displays application-wide notifications using the centralized
 * notifications context.
 *
 * @since 1.0.0
 *
 * @return JSX element.
 */
const NotificationsContainer = () => {
    const { notifications, removeNotification } = (0,_hooks__WEBPACK_IMPORTED_MODULE_2__.useNotifications)();
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_notifications_container__WEBPACK_IMPORTED_MODULE_1__.NotificationsContainer, { notifications: notifications, onDismiss: removeNotification }));
};


/***/ }),

/***/ "./src/admin/components/notifications-container/index.ts":
/*!***************************************************************!*\
  !*** ./src/admin/components/notifications-container/index.ts ***!
  \***************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   NotificationsContainer: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.NotificationsContainer; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/notifications-container/component.tsx");
/**
 * Notifications Container Export
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/components/sidebar-footer/component.tsx":
/*!***********************************************************!*\
  !*** ./src/admin/components/sidebar-footer/component.tsx ***!
  \***********************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   SidebarFooter: function() { return /* binding */ SidebarFooter; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/BookOpenIcon.js");
/* harmony import */ var _heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @heroicons/react/24/outline */ "./node_modules/@heroicons/react/24/outline/esm/LifebuoyIcon.js");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_4__);
/* harmony import */ var _styled__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./styled */ "./src/admin/components/sidebar-footer/styled.tsx");

/**
 * Sidebar Footer Component
 *
 * Footer content for the admin sidebar with Docs and Support links.
 *
 * @since 1.0.0
 */




/**
 * Sidebar Footer component
 *
 * @since 1.0.0
 *
 * @return JSX element.
 */
const SidebarFooter = () => {
    const docsUrl = 'https://www.redfoxwp.com/docs/redfox-tab-manager/';
    const supportUrl = 'https://www.redfoxwp.com/support/';
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_styled__WEBPACK_IMPORTED_MODULE_5__.FooterWrapper, { children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_3__.Flex, { direction: 'column', gap: '20px', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_5__.FooterLink, { href: docsUrl, target: '_blank', rel: 'noopener noreferrer', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_1__["default"], { width: 16, height: 16 }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("span", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_4__.__)('Documentation', 'redfox-tab-manager') })] }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_styled__WEBPACK_IMPORTED_MODULE_5__.FooterLink, { href: supportUrl, target: '_blank', rel: 'noopener noreferrer', children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_heroicons_react_24_outline__WEBPACK_IMPORTED_MODULE_2__["default"], { width: 16, height: 16 }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("span", { children: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_4__.__)('Support', 'redfox-tab-manager') })] })] }) }));
};


/***/ }),

/***/ "./src/admin/components/sidebar-footer/index.ts":
/*!******************************************************!*\
  !*** ./src/admin/components/sidebar-footer/index.ts ***!
  \******************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   SidebarFooter: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.SidebarFooter; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/sidebar-footer/component.tsx");
/**
 * Sidebar Footer
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/components/sidebar-footer/styled.tsx":
/*!********************************************************!*\
  !*** ./src/admin/components/sidebar-footer/styled.tsx ***!
  \********************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   FooterLink: function() { return /* binding */ FooterLink; },
/* harmony export */   FooterWrapper: function() { return /* binding */ FooterWrapper; }
/* harmony export */ });
/* harmony import */ var _emotion_styled__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/styled */ "./node_modules/@emotion/styled/dist/emotion-styled.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/colors */ "../../../../redfox-packages/core-components/src/colors.ts");
/**
 * Sidebar Footer Styled Components
 *
 * @since 1.0.0
 */


/**
 * Footer Wrapper
 */
const FooterWrapper = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].div `
	margin-top: auto;
`;
/**
 * Footer Link
 */
const FooterLink = _emotion_styled__WEBPACK_IMPORTED_MODULE_0__["default"].a `
	display: flex;
	align-items: center;
	gap: 8px;
	color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.gray[700]};
	text-decoration: none;
	transition: all 0.2s ease;

	&:hover {
		color: ${_redfoxwp_core_components_colors__WEBPACK_IMPORTED_MODULE_1__.colors.primary[300]};
	}

	&:focus {
		outline: none;
		box-shadow: none;
	}

	svg {
		flex-shrink: 0;
	}
`;


/***/ }),

/***/ "./src/admin/components/tab-list/component.tsx":
/*!*****************************************************!*\
  !*** ./src/admin/components/tab-list/component.tsx ***!
  \*****************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabList: function() { return /* binding */ TabList; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/components/card */ "../../../../redfox-packages/core-components/src/components/card/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @redfoxwp/core-components/components/flex */ "../../../../redfox-packages/core-components/src/components/flex/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_post_list__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @redfoxwp/core-components/components/post-list */ "../../../../redfox-packages/core-components/src/components/post-list/index.ts");
/* harmony import */ var _redfoxwp_core_components_components_tab_header__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @redfoxwp/core-components/components/tab-header */ "../../../../redfox-packages/core-components/src/components/tab-header/index.ts");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__);
/* harmony import */ var _wordpress_url__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @wordpress/url */ "@wordpress/url");
/* harmony import */ var _wordpress_url__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_wordpress_url__WEBPACK_IMPORTED_MODULE_6__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_7___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_7__);
/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../../hooks */ "./src/admin/hooks/index.ts");

/**
 * Tab List Component
 *
 * Displays and manages the list of custom tabs (CPT).
 *
 * @since 1.0.0
 */








/**
 * Tab List component
 *
 * @since 1.0.0
 *
 * @return JSX element.
 */
const TabList = () => {
    const [searchTerm, setSearchTerm] = (0,react__WEBPACK_IMPORTED_MODULE_7__.useState)('');
    // Debounce search term with 500ms delay and minimum 3 characters
    const { debouncedValue: debouncedSearchTerm } = (0,_hooks__WEBPACK_IMPORTED_MODULE_8__.useDebounce)({
        value: searchTerm,
        delay: 500,
        minLength: 3,
    });
    const { tabs, loading, pagination, deleteTab, goToPage, changeItemsPerPage } = (0,_hooks__WEBPACK_IMPORTED_MODULE_8__.useTabs)({
        search: debouncedSearchTerm,
        postsPerPage: 10,
        includeContent: true,
        allStatuses: true,
    });
    // Transform Tab[] to PostListItem[]
    const posts = (0,react__WEBPACK_IMPORTED_MODULE_7__.useMemo)(() => tabs.map((tab) => ({
        id: tab.id,
        title: {
            rendered: tab.title,
        },
        status: tab.status,
        modified: tab.modified,
        date: tab.date,
    })), [tabs]);
    const handleAddNewTab = () => {
        window.location.href = 'post-new.php?post_type=redfoxwp_tab';
    };
    const handleEditTab = (tabId) => {
        window.location.href = `post.php?post=${tabId}&action=edit`;
    };
    const handleDeleteTab = async (tabId) => {
        await deleteTab(tabId);
    };
    const handleDuplicateTab = (tabId) => {
        // Get nonce and admin URL from localized script data
        const duplicateNonce = window.redfoxTabManagerSettings?.duplicateNonce ?? '';
        const adminUrl = window.redfoxTabManagerSettings?.adminUrl ?? '/wp-admin/';
        // Navigate to duplicate with nonce
        const duplicateUrl = (0,_wordpress_url__WEBPACK_IMPORTED_MODULE_6__.addQueryArgs)(`${adminUrl}post-new.php`, {
            post_type: 'redfoxwp_tab',
            duplicate: tabId.toString(),
            _wpnonce: duplicateNonce,
        });
        window.location.href = duplicateUrl;
    };
    // Localization strings for the PostList component
    const strings = {
        searchPlaceholder: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Search tabs…', 'redfox-tab-manager'),
        addNewButton: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Add New Tab', 'redfox-tab-manager'),
        loadingText: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Loading…', 'redfox-tab-manager'),
        noPostsFound: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('No tabs found.', 'redfox-tab-manager'),
        noSearchResults: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Try adjusting your search terms or', 'redfox-tab-manager'),
        clearSearch: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('clear the search', 'redfox-tab-manager'),
        createFirstPost: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('creating your first tab', 'redfox-tab-manager'),
        editLabel: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Edit', 'redfox-tab-manager'),
        deleteModalTitle: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Delete Tab', 'redfox-tab-manager'),
        deleteModalMessage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Are you sure you want to delete this tab? This action cannot be undone.', 'redfox-tab-manager'),
        deleteConfirmButton: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Delete', 'redfox-tab-manager'),
        cancelButton: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Cancel', 'redfox-tab-manager'),
        modifiedPrefix: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Modified:', 'redfox-tab-manager'),
        statusLabels: {
            publish: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Published', 'redfox-tab-manager'),
            draft: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Draft', 'redfox-tab-manager'),
            pending: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Pending', 'redfox-tab-manager'),
            private: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Private', 'redfox-tab-manager'),
            future: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Scheduled', 'redfox-tab-manager'),
            trash: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Trash', 'redfox-tab-manager'),
        },
        pagination: {
            noItems: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('No items', 'redfox-tab-manager'),
            oneItem: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('1 item', 'redfox-tab-manager'),
            showing: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Showing', 'redfox-tab-manager'),
            of: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('of', 'redfox-tab-manager'),
            items: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('items', 'redfox-tab-manager'),
            firstPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('First page', 'redfox-tab-manager'),
            goToFirstPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Go to first page', 'redfox-tab-manager'),
            previousPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Previous page', 'redfox-tab-manager'),
            goToPreviousPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Go to previous page', 'redfox-tab-manager'),
            nextPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Next page', 'redfox-tab-manager'),
            goToNextPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Go to next page', 'redfox-tab-manager'),
            lastPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Last page', 'redfox-tab-manager'),
            goToLastPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Go to last page', 'redfox-tab-manager'),
            page: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Page', 'redfox-tab-manager'),
            goToPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Go to page', 'redfox-tab-manager'),
            itemsPerPage: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Items per page:', 'redfox-tab-manager'),
        },
        modalStrings: {
            closeModal: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Close modal', 'redfox-tab-manager'),
        },
    };
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_redfoxwp_core_components_components_flex__WEBPACK_IMPORTED_MODULE_2__.Flex, { direction: 'column', gap: '30px', fullWidth: true, children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_tab_header__WEBPACK_IMPORTED_MODULE_4__.TabHeader, { title: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Tab List', 'redfox-tab-manager'), description: (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_5__.__)('Manage individual product tabs. You can create custom tabs that can be assigned to specific products.', 'redfox-tab-manager') }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_card__WEBPACK_IMPORTED_MODULE_1__.Card, { styleProps: { padding: '30px', radius: '10px', background: '#fff' }, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_post_list__WEBPACK_IMPORTED_MODULE_3__.PostList, { posts: posts, strings: strings, loading: loading, searchTerm: searchTerm, pagination: pagination ?? undefined, actions: { edit: true, delete: true, duplicate: true, preview: false }, onSearch: setSearchTerm, onAddNew: handleAddNewTab, onEdit: handleEditTab, onDelete: handleDeleteTab, onDuplicate: handleDuplicateTab, onPageChange: goToPage, onItemsPerPageChange: changeItemsPerPage, showItemsPerPageSelector: true, itemsPerPageOptions: [10, 20, 50, 100], maxPageButtons: 7, showPageInfo: true, showFirstLastButtons: true }) })] }));
};


/***/ }),

/***/ "./src/admin/components/tab-list/index.ts":
/*!************************************************!*\
  !*** ./src/admin/components/tab-list/index.ts ***!
  \************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabList: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.TabList; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/tab-list/component.tsx");
/**
 * Tab List Component Exports
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/components/tab-manager-app/component.tsx":
/*!************************************************************!*\
  !*** ./src/admin/components/tab-manager-app/component.tsx ***!
  \************************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabManagerApp: function() { return /* binding */ TabManagerApp; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _redfoxwp_core_components_components_admin_layout__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/components/admin-layout */ "../../../../redfox-packages/core-components/src/components/admin-layout/index.ts");
/* harmony import */ var wouter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! wouter */ "./node_modules/wouter/esm/index.js");
/* harmony import */ var _global_tabs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../global-tabs */ "./src/admin/components/global-tabs/index.ts");
/* harmony import */ var _navigation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../navigation */ "./src/admin/components/navigation/index.ts");
/* harmony import */ var _sidebar_footer__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../sidebar-footer */ "./src/admin/components/sidebar-footer/index.ts");
/* harmony import */ var _tab_list__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../tab-list */ "./src/admin/components/tab-list/index.ts");

/**
 * Tab Manager App Component
 *
 * Main application component with routing for Tab Manager admin interface.
 *
 * @since 1.0.0
 */






/**
 * Tab Manager App component
 *
 * @since 1.0.0
 *
 * @param props Component props.
 *
 * @return JSX element.
 */
const TabManagerApp = (_props) => {
    return ((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_redfoxwp_core_components_components_admin_layout__WEBPACK_IMPORTED_MODULE_1__.AdminLayout, { navigation: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_navigation__WEBPACK_IMPORTED_MODULE_4__.Navigation, {}), sidebarFooter: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_sidebar_footer__WEBPACK_IMPORTED_MODULE_5__.SidebarFooter, {}), appName: window?.redfoxTabManagerSettings?.pluginName, appVersion: window?.redfoxTabManagerSettings?.pluginVersion, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(wouter__WEBPACK_IMPORTED_MODULE_2__.Switch, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(wouter__WEBPACK_IMPORTED_MODULE_2__.Route, { path: '/', children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(wouter__WEBPACK_IMPORTED_MODULE_2__.Redirect, { to: '/tabs' }) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(wouter__WEBPACK_IMPORTED_MODULE_2__.Route, { path: '/tabs', children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_tab_list__WEBPACK_IMPORTED_MODULE_6__.TabList, {}) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(wouter__WEBPACK_IMPORTED_MODULE_2__.Route, { path: '/global-tabs', children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_global_tabs__WEBPACK_IMPORTED_MODULE_3__.GlobalTabs, {}) })] }) }));
};


/***/ }),

/***/ "./src/admin/components/tab-manager-app/index.ts":
/*!*******************************************************!*\
  !*** ./src/admin/components/tab-manager-app/index.ts ***!
  \*******************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   TabManagerApp: function() { return /* reexport safe */ _component__WEBPACK_IMPORTED_MODULE_0__.TabManagerApp; }
/* harmony export */ });
/* harmony import */ var _component__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./component */ "./src/admin/components/tab-manager-app/component.tsx");
/**
 * Tab Manager App Component Exports
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/contexts/global-tabs-context.tsx":
/*!****************************************************!*\
  !*** ./src/admin/contexts/global-tabs-context.tsx ***!
  \****************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabsProvider: function() { return /* binding */ GlobalTabsProvider; },
/* harmony export */   useGlobalTabsContext: function() { return /* binding */ useGlobalTabsContext; }
/* harmony export */ });
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var _hooks__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../hooks */ "./src/admin/hooks/index.ts");
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../utils */ "./src/admin/utils/index.ts");

/**
 * Global Tabs Context
 *
 * React context for managing global tabs state and operations.
 *
 * @since 1.0.0
 */




/**
 * Global tabs context
 *
 * @since 1.0.0
 */
const GlobalTabsContext = (0,react__WEBPACK_IMPORTED_MODULE_2__.createContext)(undefined);
/**
 * Global tabs context provider
 *
 * @since 1.0.0
 *
 * @param props Provider props.
 *
 * @return JSX element.
 */
const GlobalTabsProvider = ({ children }) => {
    const [isSaving, setIsSaving] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)(false);
    const [isDeleting, setIsDeleting] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)(false);
    // Get centralized notifications
    const { showSuccess: showGlobalSuccess, showError: showGlobalError } = (0,_hooks__WEBPACK_IMPORTED_MODULE_3__.useNotifications)();
    // Notification handlers
    const handleError = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)((message) => {
        showGlobalError(message);
    }, [showGlobalError]);
    const handleSuccess = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)((message) => {
        showGlobalSuccess(message);
    }, [showGlobalSuccess]);
    // Use the data hook
    const { tabs, loading, error, hasUnsavedChanges, updateTabs, resetTabs, fetchTabs, fetchRedFoxTabs, } = (0,_hooks__WEBPACK_IMPORTED_MODULE_3__.useGlobalTabs)({
        onError: handleError,
    });
    // Business operation: Save tabs
    const saveTabs = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(async () => {
        try {
            setIsSaving(true);
            const response = await (0,_utils__WEBPACK_IMPORTED_MODULE_4__.saveGlobalTabs)(tabs);
            handleSuccess(response.message);
            // Refresh data from API after successful save to sync originalTabs
            await fetchTabs();
            return true;
        }
        catch {
            const errorMessage = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Failed to save global tabs. Please try again.', 'redfox-tab-manager');
            handleError(errorMessage);
            return false;
        }
        finally {
            setIsSaving(false);
        }
    }, [tabs, handleSuccess, handleError, fetchTabs]);
    // Business operation: Delete tab (removes from context data only, save operation persists to DB)
    const deleteTab = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(async (tabId) => {
        const tab = tabs.find((t) => t.id === tabId);
        // Don't allow deletion of WooCommerce default tabs
        if (tab && tab.type === 'woocommerce_default') {
            handleError((0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('WooCommerce default tabs cannot be deleted.', 'redfox-tab-manager'));
            return false;
        }
        try {
            setIsDeleting(true);
            // Remove the tab from local state only
            // The save operation will handle persisting changes to the database
            const updatedTabs = tabs.filter((tabItem) => tabItem.id !== tabId);
            updateTabs(updatedTabs);
            return true;
        }
        catch {
            const errorMessage = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Failed to remove tab. Please try again.', 'redfox-tab-manager');
            handleError(errorMessage);
            return false;
        }
        finally {
            setIsDeleting(false);
        }
    }, [tabs, handleError, updateTabs]);
    // Business operation: Reset to defaults
    const resetToDefaults = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(async () => {
        try {
            setIsSaving(true);
            const response = await (0,_utils__WEBPACK_IMPORTED_MODULE_4__.resetGlobalTabsToDefaults)();
            handleSuccess(response.message);
            // Refresh data from API after successful reset to sync state
            await fetchTabs();
            return true;
        }
        catch {
            const errorMessage = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Failed to reset global tabs to defaults. Please try again.', 'redfox-tab-manager');
            handleError(errorMessage);
            return false;
        }
        finally {
            setIsSaving(false);
        }
    }, [handleSuccess, handleError, fetchTabs]);
    const contextValue = {
        // Data state
        tabs,
        loading,
        error,
        hasUnsavedChanges,
        // Operation states
        isSaving,
        isDeleting,
        // Data operations
        updateTabs,
        resetTabs,
        resetToDefaults,
        fetchTabs,
        fetchRedFoxTabs,
        // Business operations
        saveTabs,
        deleteTab,
    };
    return (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(GlobalTabsContext.Provider, { value: contextValue, children: children });
};
/**
 * Hook to use global tabs context
 *
 * @since 1.0.0
 *
 * @return Global tabs context state.
 */
const useGlobalTabsContext = () => {
    const context = (0,react__WEBPACK_IMPORTED_MODULE_2__.useContext)(GlobalTabsContext);
    if (context === undefined) {
        throw new Error('useGlobalTabsContext must be used within a GlobalTabsProvider');
    }
    return context;
};


/***/ }),

/***/ "./src/admin/contexts/index.ts":
/*!*************************************!*\
  !*** ./src/admin/contexts/index.ts ***!
  \*************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   GlobalTabsProvider: function() { return /* reexport safe */ _global_tabs_context__WEBPACK_IMPORTED_MODULE_0__.GlobalTabsProvider; },
/* harmony export */   NotificationProvider: function() { return /* reexport safe */ _redfoxwp_core_components_contexts_notification_context__WEBPACK_IMPORTED_MODULE_1__.NotificationProvider; },
/* harmony export */   useGlobalTabsContext: function() { return /* reexport safe */ _global_tabs_context__WEBPACK_IMPORTED_MODULE_0__.useGlobalTabsContext; }
/* harmony export */ });
/* harmony import */ var _global_tabs_context__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./global-tabs-context */ "./src/admin/contexts/global-tabs-context.tsx");
/* harmony import */ var _redfoxwp_core_components_contexts_notification_context__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @redfoxwp/core-components/contexts/notification-context */ "../../../../redfox-packages/core-components/src/contexts/notification-context/index.ts");
/**
 * Admin Contexts Export
 *
 * @since 1.0.0
 */




/***/ }),

/***/ "./src/admin/hooks/index.ts":
/*!**********************************!*\
  !*** ./src/admin/hooks/index.ts ***!
  \**********************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useDebounce: function() { return /* reexport safe */ _use_debounce__WEBPACK_IMPORTED_MODULE_3__.useDebounce; },
/* harmony export */   useGlobalTabs: function() { return /* reexport safe */ _use_global_tabs__WEBPACK_IMPORTED_MODULE_1__.useGlobalTabs; },
/* harmony export */   useNavigationGuard: function() { return /* reexport safe */ _use_navigation_guard__WEBPACK_IMPORTED_MODULE_2__.useNavigationGuard; },
/* harmony export */   useNotifications: function() { return /* reexport safe */ _use_notifications__WEBPACK_IMPORTED_MODULE_4__.useNotifications; },
/* harmony export */   useTabs: function() { return /* reexport safe */ _use_tabs__WEBPACK_IMPORTED_MODULE_0__.useTabs; }
/* harmony export */ });
/* harmony import */ var _use_tabs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./use-tabs */ "./src/admin/hooks/use-tabs/index.ts");
/* harmony import */ var _use_global_tabs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./use-global-tabs */ "./src/admin/hooks/use-global-tabs/index.ts");
/* harmony import */ var _use_navigation_guard__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./use-navigation-guard */ "./src/admin/hooks/use-navigation-guard/index.ts");
/* harmony import */ var _use_debounce__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./use-debounce */ "./src/admin/hooks/use-debounce/index.ts");
/* harmony import */ var _use_notifications__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./use-notifications */ "./src/admin/hooks/use-notifications/index.ts");
/**
 * Admin Hooks Index
 *
 * Exports all admin hooks for easy importing.
 *
 * @since 1.0.0
 */
// Existing hooks

// Global tabs hook

// Navigation guard hook

// Debounce hook

// Notifications hook



/***/ }),

/***/ "./src/admin/hooks/use-debounce/hook.ts":
/*!**********************************************!*\
  !*** ./src/admin/hooks/use-debounce/hook.ts ***!
  \**********************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useDebounce: function() { return /* binding */ useDebounce; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/**
 * Use Debounce Hook
 *
 * Custom hook for debouncing values to prevent excessive API calls.
 *
 * @since 1.0.0
 */

/**
 * Custom hook for debouncing values
 *
 * @since 1.0.0
 *
 * @param params Hook parameters.
 *
 * @return Debounced value.
 */
const useDebounce = (params) => {
    const { value, delay = 300, minLength = 0 } = params;
    const [debouncedValue, setDebouncedValue] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(value);
    (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
        // If value is a string and doesn't meet minimum length, don't debounce
        if (typeof value === 'string' && value.length > 0 && value.length < minLength) {
            // Reset to empty string or initial value if below minimum length
            setDebouncedValue('');
            return;
        }
        // Set up the debounce timer
        const timer = setTimeout(() => {
            setDebouncedValue(value);
        }, delay);
        // Cleanup timer on value change or component unmount
        return () => {
            clearTimeout(timer);
        };
    }, [value, delay, minLength]);
    return {
        debouncedValue,
    };
};


/***/ }),

/***/ "./src/admin/hooks/use-debounce/index.ts":
/*!***********************************************!*\
  !*** ./src/admin/hooks/use-debounce/index.ts ***!
  \***********************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useDebounce: function() { return /* reexport safe */ _hook__WEBPACK_IMPORTED_MODULE_0__.useDebounce; }
/* harmony export */ });
/* harmony import */ var _hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hook */ "./src/admin/hooks/use-debounce/hook.ts");
/**
 * Use Debounce Hook
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/hooks/use-global-tabs/hook.ts":
/*!*************************************************!*\
  !*** ./src/admin/hooks/use-global-tabs/hook.ts ***!
  \*************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useGlobalTabs: function() { return /* binding */ useGlobalTabs; }
/* harmony export */ });
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @wordpress/api-fetch */ "@wordpress/api-fetch");
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_2__);
/**
 * Use Global Tabs Hook Implementation
 *
 * Custom hook for fetching and managing global tabs data from API.
 * This hook is only responsible for data fetching and local state management.
 *
 * @since 1.0.0
 */



/**
 * Custom hook for managing global tabs data
 *
 * @since 1.0.0
 *
 * @param params Hook parameters.
 *
 * @return Hook return value.
 */
const useGlobalTabs = (params = {}) => {
    const { autoLoad = true, onError } = params;
    const [tabs, setTabs] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)([]);
    const [originalTabs, setOriginalTabs] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)([]);
    const [loading, setLoading] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)(false);
    const [error, setError] = (0,react__WEBPACK_IMPORTED_MODULE_2__.useState)(null);
    // Check if there are unsaved changes
    const hasUnsavedChanges = JSON.stringify(tabs) !== JSON.stringify(originalTabs);
    /**
     * Show error notification
     *
     * @since 1.0.0
     *
     * @param message Error message.
     */
    const showError = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)((message) => {
        setError(message);
        if (onError) {
            onError(message);
        }
    }, [onError]);
    /**
     * Fetch global tabs from API
     *
     * @since 1.0.0
     */
    const fetchTabs = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(async () => {
        try {
            setLoading(true);
            setError(null);
            const response = await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
                path: '/redfox-tab-manager/v1/global-tabs',
                method: 'GET',
            });
            // Extract data from API response wrapper
            const tabsData = response?.data ?? response;
            // Ensure response is always an array
            const tabsArray = Array.isArray(tabsData) ? tabsData : [];
            setTabs(tabsArray);
            setOriginalTabs(tabsArray);
        }
        catch {
            const errorMessage = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Failed to load global tabs. Please try again.', 'redfox-tab-manager');
            showError(errorMessage);
            setTabs([]);
            setOriginalTabs([]);
        }
        finally {
            setLoading(false);
        }
    }, [showError]);
    /**
     * Update tabs without saving
     *
     * @since 1.0.0
     *
     * @param newTabs New tabs array.
     */
    const updateTabs = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)((newTabs) => {
        setTabs(newTabs);
    }, []);
    /**
     * Reset tabs to original state
     *
     * @since 1.0.0
     */
    const resetTabs = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(() => {
        setTabs(originalTabs);
    }, [originalTabs]);
    /**
     * Fetch RedFox tabs (CPT)
     *
     * @since 1.0.0
     *
     * @param params Fetch parameters.
     *
     * @return Array of RedFox tabs.
     */
    const fetchRedFoxTabs = (0,react__WEBPACK_IMPORTED_MODULE_2__.useCallback)(async (fetchParams = {}) => {
        try {
            const { postsPerPage = -1, orderBy = 'date', order = 'DESC' } = fetchParams;
            const queryParams = new URLSearchParams({
                posts_per_page: postsPerPage.toString(),
                orderby: orderBy,
                order,
                include_content: 'true',
            });
            const apiUrl = `/redfox-tab-manager/v1/available-tabs?${queryParams.toString()}`;
            const response = await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
                path: apiUrl,
            });
            // Extract data from API response wrapper
            const tabsData = response?.data ?? response;
            return Array.isArray(tabsData) ? tabsData : [];
        }
        catch {
            const errorMessage = (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Failed to fetch RedFox tabs. Please try again.', 'redfox-tab-manager');
            showError(errorMessage);
            return [];
        }
    }, [showError]);
    // Auto-load tabs on mount
    (0,react__WEBPACK_IMPORTED_MODULE_2__.useEffect)(() => {
        if (autoLoad) {
            fetchTabs();
        }
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, []);
    return {
        tabs,
        loading,
        error,
        hasUnsavedChanges,
        fetchTabs,
        updateTabs,
        resetTabs,
        fetchRedFoxTabs,
    };
};


/***/ }),

/***/ "./src/admin/hooks/use-global-tabs/index.ts":
/*!**************************************************!*\
  !*** ./src/admin/hooks/use-global-tabs/index.ts ***!
  \**************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useGlobalTabs: function() { return /* reexport safe */ _hook__WEBPACK_IMPORTED_MODULE_0__.useGlobalTabs; }
/* harmony export */ });
/* harmony import */ var _hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hook */ "./src/admin/hooks/use-global-tabs/hook.ts");
/**
 * Use Global Tabs Hook
 *
 * Exports for the use-global-tabs hook.
 *
 * @since 1.0.0
 */
// Export hook



/***/ }),

/***/ "./src/admin/hooks/use-navigation-guard/hook.ts":
/*!******************************************************!*\
  !*** ./src/admin/hooks/use-navigation-guard/hook.ts ***!
  \******************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useNavigationGuard: function() { return /* binding */ useNavigationGuard; }
/* harmony export */ });
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../utils */ "./src/admin/utils/index.ts");
/**
 * Use Navigation Guard Hook
 *
 * Custom hook for monitoring unsaved changes state and managing navigation warnings.
 *
 * @since 1.0.0
 */


/**
 * Hook for monitoring navigation guard state
 *
 * @since 1.0.0
 *
 * @return Object with unsaved changes state.
 */
const useNavigationGuard = () => {
    const [hasUnsavedChanges, setHasUnsavedChanges] = (0,react__WEBPACK_IMPORTED_MODULE_0__.useState)(false);
    (0,react__WEBPACK_IMPORTED_MODULE_0__.useEffect)(() => {
        const unsubscribe = (0,_utils__WEBPACK_IMPORTED_MODULE_1__.subscribeToUnsavedChanges)((hasChanges) => {
            setHasUnsavedChanges(hasChanges);
        });
        return unsubscribe;
    }, []);
    return {
        hasUnsavedChanges,
    };
};


/***/ }),

/***/ "./src/admin/hooks/use-navigation-guard/index.ts":
/*!*******************************************************!*\
  !*** ./src/admin/hooks/use-navigation-guard/index.ts ***!
  \*******************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useNavigationGuard: function() { return /* reexport safe */ _hook__WEBPACK_IMPORTED_MODULE_0__.useNavigationGuard; }
/* harmony export */ });
/* harmony import */ var _hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hook */ "./src/admin/hooks/use-navigation-guard/hook.ts");
/**
 * Use Navigation Guard Hook Export
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/hooks/use-notifications/hook.ts":
/*!***************************************************!*\
  !*** ./src/admin/hooks/use-notifications/hook.ts ***!
  \***************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useNotifications: function() { return /* binding */ useNotifications; }
/* harmony export */ });
/* harmony import */ var _redfoxwp_core_components_contexts_notification_context__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @redfoxwp/core-components/contexts/notification-context */ "../../../../redfox-packages/core-components/src/contexts/notification-context/index.ts");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/**
 * Use Notifications Hook
 *
 * Custom hook for accessing the notifications context with helper methods.
 * Wraps the core-components notification context to provide convenience methods.
 *
 * @since 1.0.0
 */


/**
 * Hook to use notifications with helper methods
 *
 * @since 1.0.0
 *
 * @return Notifications state with helper methods.
 */
const useNotifications = () => {
    const { notifications, addNotification, removeNotification, clearNotifications } = (0,_redfoxwp_core_components_contexts_notification_context__WEBPACK_IMPORTED_MODULE_0__.useNotification)();
    /**
     * Add a notification with custom options
     *
     * @since 1.0.0
     *
     * @param notification Notification configuration.
     *
     * @return Notification ID.
     */
    const addNotificationWrapper = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((notification) => {
        const { variant, message, duration, dismissible } = notification;
        // Convert duration format: false -> autoDismiss: false, number -> use duration
        const options = {
            dismissible: dismissible ?? true,
            autoDismiss: duration !== false,
            duration: typeof duration === 'number' ? duration : 5000,
        };
        return addNotification(variant, message, options);
    }, [addNotification]);
    /**
     * Show success notification
     *
     * @since 1.0.0
     *
     * @param message Notification message.
     * @param options Optional configuration.
     *
     * @return Notification ID.
     */
    const showSuccess = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((message, options) => {
        return addNotificationWrapper({
            variant: 'success',
            message,
            ...options,
        });
    }, [addNotificationWrapper]);
    /**
     * Show error notification
     *
     * @since 1.0.0
     *
     * @param message Notification message.
     * @param options Optional configuration.
     *
     * @return Notification ID.
     */
    const showError = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((message, options) => {
        return addNotificationWrapper({
            variant: 'error',
            message,
            ...options,
        });
    }, [addNotificationWrapper]);
    /**
     * Show warning notification
     *
     * @since 1.0.0
     *
     * @param message Notification message.
     * @param options Optional configuration.
     *
     * @return Notification ID.
     */
    const showWarning = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((message, options) => {
        return addNotificationWrapper({
            variant: 'warning',
            message,
            ...options,
        });
    }, [addNotificationWrapper]);
    /**
     * Show info notification
     *
     * @since 1.0.0
     *
     * @param message Notification message.
     * @param options Optional configuration.
     *
     * @return Notification ID.
     */
    const showInfo = (0,react__WEBPACK_IMPORTED_MODULE_1__.useCallback)((message, options) => {
        return addNotificationWrapper({
            variant: 'info',
            message,
            ...options,
        });
    }, [addNotificationWrapper]);
    return {
        notifications,
        addNotification: addNotificationWrapper,
        removeNotification,
        clearNotifications,
        showSuccess,
        showError,
        showWarning,
        showInfo,
    };
};


/***/ }),

/***/ "./src/admin/hooks/use-notifications/index.ts":
/*!****************************************************!*\
  !*** ./src/admin/hooks/use-notifications/index.ts ***!
  \****************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useNotifications: function() { return /* reexport safe */ _hook__WEBPACK_IMPORTED_MODULE_0__.useNotifications; }
/* harmony export */ });
/* harmony import */ var _hook__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./hook */ "./src/admin/hooks/use-notifications/hook.ts");
/* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./types */ "./src/admin/hooks/use-notifications/types.ts");
/**
 * Use Notifications Hook Export
 *
 * @since 1.0.0
 */




/***/ }),

/***/ "./src/admin/hooks/use-notifications/types.ts":
/*!****************************************************!*\
  !*** ./src/admin/hooks/use-notifications/types.ts ***!
  \****************************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/**
 * Use Notifications Hook Types
 *
 * Type definitions for the notifications hook.
 *
 * @since 1.0.0
 */



/***/ }),

/***/ "./src/admin/hooks/use-tabs/index.ts":
/*!*******************************************!*\
  !*** ./src/admin/hooks/use-tabs/index.ts ***!
  \*******************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   useTabs: function() { return /* binding */ useTabs; }
/* harmony export */ });
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @wordpress/api-fetch */ "@wordpress/api-fetch");
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react */ "react");
/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_1__);
/**
 * Use Tabs Hook
 *
 * Custom hook for fetching and managing tabs data.
 *
 * @since 1.0.0
 */


/**
 * Custom hook for managing tabs data
 *
 * @since 1.0.0
 *
 * @param params Hook parameters.
 *
 * @return Hook return value.
 */
const useTabs = (params = {}) => {
    const { search = '', postsPerPage = 20, page: initialPage = 1, orderBy = 'date', order = 'DESC', includeContent = true, allStatuses = false, } = params;
    const [tabs, setTabs] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)([]);
    const [loading, setLoading] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(true);
    const [error, setError] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(null);
    const [pagination, setPagination] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(null);
    const [currentPage, setCurrentPage] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(initialPage);
    const [currentPostsPerPage, setCurrentPostsPerPage] = (0,react__WEBPACK_IMPORTED_MODULE_1__.useState)(postsPerPage);
    const fetchTabs = async () => {
        try {
            setLoading(true);
            setError(null);
            const queryParams = new URLSearchParams({
                search,
                posts_per_page: currentPostsPerPage.toString(),
                page: currentPage.toString(),
                orderby: orderBy,
                order,
                include_content: includeContent.toString(),
                all_statuses: allStatuses.toString(),
            });
            const apiUrl = `/redfox-tab-manager/v1/available-tabs?${queryParams.toString()}`;
            const response = await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
                path: apiUrl,
            });
            if (response?.data) {
                setTabs(response.data);
                // Set pagination info
                if (response.pagination) {
                    setPagination({
                        currentPage: response.pagination.current_page,
                        totalPages: response.pagination.total_pages,
                        totalItems: response.pagination.total_items,
                        itemsPerPage: response.pagination.items_per_page,
                        hasNextPage: response.pagination.has_next_page,
                        hasPrevPage: response.pagination.has_prev_page,
                    });
                }
                else {
                    setPagination(null);
                }
            }
            else {
                setTabs([]);
                setPagination(null);
            }
        }
        catch (err) {
            // eslint-disable-next-line no-console
            console.error('Failed to fetch tabs:', err);
            setError(err instanceof Error ? err.message : 'Failed to fetch tabs');
            setTabs([]);
            setPagination(null);
        }
        finally {
            setLoading(false);
        }
    };
    const deleteTab = async (tabId) => {
        try {
            await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
                path: `/wp/v2/redfoxwp_tab/${tabId}`,
                method: 'DELETE',
            });
            // Remove the deleted tab from local state
            setTabs((prevTabs) => prevTabs.filter((tab) => tab.id !== tabId));
            return true;
        }
        catch (err) {
            // eslint-disable-next-line no-console
            console.error('Failed to delete tab:', err);
            setError(err instanceof Error ? err.message : 'Failed to delete tab');
            return false;
        }
    };
    /**
     * Navigate to a specific page
     *
     * @since 1.0.0
     *
     * @param page Page number to navigate to.
     */
    const goToPage = (page) => {
        if (page >= 1 && (!pagination || page <= pagination.totalPages)) {
            setCurrentPage(page);
        }
    };
    /**
     * Change items per page
     *
     * @since 1.0.0
     *
     * @param itemsPerPage Number of items per page.
     */
    const changeItemsPerPage = (itemsPerPage) => {
        setCurrentPostsPerPage(itemsPerPage);
        setCurrentPage(1); // Reset to first page when changing items per page
    };
    (0,react__WEBPACK_IMPORTED_MODULE_1__.useEffect)(() => {
        fetchTabs();
        // eslint-disable-next-line react-hooks/exhaustive-deps
    }, [search, currentPostsPerPage, currentPage, orderBy, order, includeContent, allStatuses]);
    return {
        tabs,
        loading,
        error,
        pagination,
        refetch: fetchTabs,
        deleteTab,
        goToPage,
        changeItemsPerPage,
    };
};


/***/ }),

/***/ "./src/admin/utils/api.ts":
/*!********************************!*\
  !*** ./src/admin/utils/api.ts ***!
  \********************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   resetGlobalTabsToDefaults: function() { return /* binding */ resetGlobalTabsToDefaults; },
/* harmony export */   saveGlobalTabs: function() { return /* binding */ saveGlobalTabs; }
/* harmony export */ });
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @wordpress/api-fetch */ "@wordpress/api-fetch");
/* harmony import */ var _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__);
/**
 * API Utility Functions
 *
 * Utility functions for API operations.
 *
 * @since 1.0.0
 */


/**
 * Save global tabs to API
 *
 * @since 1.0.0
 *
 * @param tabs Tabs to save.
 *
 * @return Promise with response data.
 */
const saveGlobalTabs = async (tabs) => {
    // Update priorities based on current order using (10 * index) + 10
    const tabsWithUpdatedPriorities = tabs.map((tab, index) => ({
        ...tab,
        priority: 10 * index + 10,
    }));
    const response = await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
        path: '/redfox-tab-manager/v1/global-tabs',
        method: 'POST',
        data: { tabs: tabsWithUpdatedPriorities },
    });
    return {
        success: true,
        message: response?.message ?? (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Global tabs saved successfully!', 'redfox-tab-manager'),
    };
};
/**
 * Reset global tabs to defaults via API
 *
 * @since 1.0.0
 *
 * @return Promise with response data and default tabs.
 */
const resetGlobalTabsToDefaults = async () => {
    const response = await _wordpress_api_fetch__WEBPACK_IMPORTED_MODULE_0___default()({
        path: '/redfox-tab-manager/v1/global-tabs/reset-to-defaults',
        method: 'POST',
    });
    return {
        success: true,
        message: response?.message ?? (0,_wordpress_i18n__WEBPACK_IMPORTED_MODULE_1__.__)('Global tabs reset to defaults successfully!', 'redfox-tab-manager'),
        data: response?.data ?? [],
    };
};


/***/ }),

/***/ "./src/admin/utils/index.ts":
/*!**********************************!*\
  !*** ./src/admin/utils/index.ts ***!
  \**********************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getUnsavedChanges: function() { return /* reexport safe */ _navigation_guard__WEBPACK_IMPORTED_MODULE_1__.getUnsavedChanges; },
/* harmony export */   resetGlobalTabsToDefaults: function() { return /* reexport safe */ _api__WEBPACK_IMPORTED_MODULE_0__.resetGlobalTabsToDefaults; },
/* harmony export */   saveGlobalTabs: function() { return /* reexport safe */ _api__WEBPACK_IMPORTED_MODULE_0__.saveGlobalTabs; },
/* harmony export */   setUnsavedChanges: function() { return /* reexport safe */ _navigation_guard__WEBPACK_IMPORTED_MODULE_1__.setUnsavedChanges; },
/* harmony export */   subscribeToUnsavedChanges: function() { return /* reexport safe */ _navigation_guard__WEBPACK_IMPORTED_MODULE_1__.subscribeToUnsavedChanges; }
/* harmony export */ });
/* harmony import */ var _api__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./api */ "./src/admin/utils/api.ts");
/* harmony import */ var _navigation_guard__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./navigation-guard */ "./src/admin/utils/navigation-guard.ts");
/**
 * Admin Utils Export
 *
 * @since 1.0.0
 */




/***/ }),

/***/ "./src/admin/utils/navigation-guard.ts":
/*!*********************************************!*\
  !*** ./src/admin/utils/navigation-guard.ts ***!
  \*********************************************/
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   getUnsavedChanges: function() { return /* binding */ getUnsavedChanges; },
/* harmony export */   setUnsavedChanges: function() { return /* binding */ setUnsavedChanges; },
/* harmony export */   subscribeToUnsavedChanges: function() { return /* binding */ subscribeToUnsavedChanges; }
/* harmony export */ });
/**
 * Navigation Guard Utility
 *
 * Simple event-based system to manage navigation warnings when there are unsaved changes.
 *
 * @since 1.0.0
 */
const state = {
    hasUnsavedChanges: false,
    listeners: new Set(),
};
/**
 * Set the unsaved changes state
 *
 * @since 1.0.0
 *
 * @param hasChanges Whether there are unsaved changes.
 */
const setUnsavedChanges = (hasChanges) => {
    state.hasUnsavedChanges = hasChanges;
    state.listeners.forEach((listener) => listener(hasChanges));
};
/**
 * Get the current unsaved changes state
 *
 * @since 1.0.0
 *
 * @return Whether there are unsaved changes.
 */
const getUnsavedChanges = () => {
    return state.hasUnsavedChanges;
};
/**
 * Subscribe to unsaved changes state updates
 *
 * @since 1.0.0
 *
 * @param listener Callback function.
 *
 * @return Unsubscribe function.
 */
const subscribeToUnsavedChanges = (listener) => {
    state.listeners.add(listener);
    // Call immediately with current state
    listener(state.hasUnsavedChanges);
    return () => {
        state.listeners.delete(listener);
    };
};


/***/ }),

/***/ "@wordpress/api-fetch":
/*!**********************************!*\
  !*** external ["wp","apiFetch"] ***!
  \**********************************/
/***/ (function(module) {

module.exports = window["wp"]["apiFetch"];

/***/ }),

/***/ "@wordpress/i18n":
/*!******************************!*\
  !*** external ["wp","i18n"] ***!
  \******************************/
/***/ (function(module) {

module.exports = window["wp"]["i18n"];

/***/ }),

/***/ "@wordpress/url":
/*!*****************************!*\
  !*** external ["wp","url"] ***!
  \*****************************/
/***/ (function(module) {

module.exports = window["wp"]["url"];

/***/ }),

/***/ "react":
/*!************************!*\
  !*** external "React" ***!
  \************************/
/***/ (function(module) {

module.exports = window["React"];

/***/ }),

/***/ "react-dom":
/*!***************************!*\
  !*** external "ReactDOM" ***!
  \***************************/
/***/ (function(module) {

module.exports = window["ReactDOM"];

/***/ }),

/***/ "react/jsx-runtime":
/*!**********************************!*\
  !*** external "ReactJSXRuntime" ***!
  \**********************************/
/***/ (function(module) {

module.exports = window["ReactJSXRuntime"];

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	!function() {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = function(module) {
/******/ 			var getter = module && module.__esModule ?
/******/ 				function() { return module['default']; } :
/******/ 				function() { return module; };
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/create fake namespace object */
/******/ 	!function() {
/******/ 		var getProto = Object.getPrototypeOf ? function(obj) { return Object.getPrototypeOf(obj); } : function(obj) { return obj.__proto__; };
/******/ 		var leafPrototypes;
/******/ 		// create a fake namespace object
/******/ 		// mode & 1: value is a module id, require it
/******/ 		// mode & 2: merge all properties of value into the ns
/******/ 		// mode & 4: return value when already ns object
/******/ 		// mode & 16: return value when it's Promise-like
/******/ 		// mode & 8|1: behave like require
/******/ 		__webpack_require__.t = function(value, mode) {
/******/ 			if(mode & 1) value = this(value);
/******/ 			if(mode & 8) return value;
/******/ 			if(typeof value === 'object' && value) {
/******/ 				if((mode & 4) && value.__esModule) return value;
/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
/******/ 			}
/******/ 			var ns = Object.create(null);
/******/ 			__webpack_require__.r(ns);
/******/ 			var def = {};
/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
/******/ 			for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {
/******/ 				Object.getOwnPropertyNames(current).forEach(function(key) { def[key] = function() { return value[key]; }; });
/******/ 			}
/******/ 			def['default'] = function() { return value; };
/******/ 			__webpack_require__.d(ns, def);
/******/ 			return ns;
/******/ 		};
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	!function() {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = function(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/global */
/******/ 	!function() {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	!function() {
/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ 	}();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	!function() {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = function(exports) {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	}();
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
!function() {
/*!*****************************!*\
  !*** ./src/admin/index.tsx ***!
  \*****************************/
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @emotion/react/jsx-runtime */ "./node_modules/@emotion/react/jsx-runtime/dist/emotion-react-jsx-runtime.browser.development.esm.js");
/* harmony import */ var react_dom_client__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! react-dom/client */ "./node_modules/react-dom/client.js");
/* harmony import */ var wouter__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! wouter */ "./node_modules/wouter/esm/index.js");
/* harmony import */ var wouter_use_hash_location__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! wouter/use-hash-location */ "./node_modules/wouter/esm/use-hash-location.js");
/* harmony import */ var _components__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./components */ "./src/admin/components/index.ts");
/* harmony import */ var _contexts__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./contexts */ "./src/admin/contexts/index.ts");

/**
 * Main Admin Interface
 *
 * React-based admin interface with routing for Tab Manager.
 *
 * @since 1.0.0
 */





/**
 * Initialize the admin interface
 *
 * @since 1.0.0
 */
const initializeAdmin = () => {
    const container = document.getElementById('redfox-tab-manager-root');
    if (!container) {
        return;
    }
    const root = (0,react_dom_client__WEBPACK_IMPORTED_MODULE_1__.createRoot)(container);
    root.render((0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)(_contexts__WEBPACK_IMPORTED_MODULE_5__.NotificationProvider, { children: [(0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(wouter__WEBPACK_IMPORTED_MODULE_2__.Router, { hook: wouter_use_hash_location__WEBPACK_IMPORTED_MODULE_3__.useHashLocation, children: (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_components__WEBPACK_IMPORTED_MODULE_4__.TabManagerApp, {}) }), (0,_emotion_react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(_components__WEBPACK_IMPORTED_MODULE_4__.NotificationsContainer, {})] }));
};
// Initialize when DOM is ready
if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', initializeAdmin);
}
else {
    initializeAdmin();
}

}();
/******/ })()
;
//# sourceMappingURL=admin.js.map