@feathery/react 2.12.2 → 2.12.3-pr-1522.4bcc507.0

package/dist/cjs/{fthry_index.vmA_xfxy.js → fthry_index.DvJ038DD.js}

@@ -1,17 +1,16 @@
 'use strict';
 
-var index$3 = require('./fthry_index.Di_2sd1H.js');
+var index$3 = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
-var Placeholder = require('./fthry_Placeholder.DExePn4A.js');
-var InlineTooltip = require('./fthry_InlineTooltip.7d1XAj6X.js');
+var Placeholder = require('./fthry_Placeholder.BmZn9eqe.js');
+var InlineTooltip = require('./fthry_InlineTooltip.CbVeAbj-.js');
 var ReactJSXRuntime = require('react/jsx-runtime');
 var ReactDOM = require('react-dom');
-var floatingUi_utils = require('./fthry_floating-ui.utils.D2KLOgYj.js');
-var input = require('./fthry_input.DWFkBuAl.js');
+var input = require('./fthry_input.BhfAe7t1.js');
 require('react-dom/client');
 require('jszip');
-require('./fthry_Overlay.Bw-JWkvN.js');
-require('./fthry_index.NNL4lQSw.js');
+require('./fthry_Overlay.zp3MDZez.js');
+require('./fthry_index.sQV37Gt2.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -2021,7 +2020,7 @@ function addYears(date, amount) {
  * ])
  * //=> Sun Jul 02 1995 00:00:00
  */
-function max(dates) {
+function max$1(dates) {
   let result;
   dates.forEach(function (dirtyDate) {
     const currentDate = toDate(dirtyDate);
@@ -2062,7 +2061,7 @@ function max(dates) {
  * ])
  * //=> Wed Feb 11 1987 00:00:00
  */
-function min(dates) {
+function min$1(dates) {
   let result;
 
   dates.forEach((dirtyDate) => {
@@ -8751,6 +8750,141 @@ function getFrameElement(win) {
   return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
 
+/**
+ * Custom positioning reference element.
+ * @see https://floating-ui.com/docs/virtual-elements
+ */
+
+const min = Math.min;
+const max = Math.max;
+const round = Math.round;
+const floor = Math.floor;
+const createCoords = v => ({
+  x: v,
+  y: v
+});
+const oppositeSideMap = {
+  left: 'right',
+  right: 'left',
+  bottom: 'top',
+  top: 'bottom'
+};
+const oppositeAlignmentMap = {
+  start: 'end',
+  end: 'start'
+};
+function clamp(start, value, end) {
+  return max(start, min(value, end));
+}
+function evaluate(value, param) {
+  return typeof value === 'function' ? value(param) : value;
+}
+function getSide(placement) {
+  return placement.split('-')[0];
+}
+function getAlignment(placement) {
+  return placement.split('-')[1];
+}
+function getOppositeAxis(axis) {
+  return axis === 'x' ? 'y' : 'x';
+}
+function getAxisLength(axis) {
+  return axis === 'y' ? 'height' : 'width';
+}
+const yAxisSides = /*#__PURE__*/new Set(['top', 'bottom']);
+function getSideAxis(placement) {
+  return yAxisSides.has(getSide(placement)) ? 'y' : 'x';
+}
+function getAlignmentAxis(placement) {
+  return getOppositeAxis(getSideAxis(placement));
+}
+function getAlignmentSides(placement, rects, rtl) {
+  if (rtl === void 0) {
+    rtl = false;
+  }
+  const alignment = getAlignment(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const length = getAxisLength(alignmentAxis);
+  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';
+  if (rects.reference[length] > rects.floating[length]) {
+    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
+  }
+  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
+}
+function getExpandedPlacements(placement) {
+  const oppositePlacement = getOppositePlacement(placement);
+  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
+}
+function getOppositeAlignmentPlacement(placement) {
+  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);
+}
+const lrPlacement = ['left', 'right'];
+const rlPlacement = ['right', 'left'];
+const tbPlacement = ['top', 'bottom'];
+const btPlacement = ['bottom', 'top'];
+function getSideList(side, isStart, rtl) {
+  switch (side) {
+    case 'top':
+    case 'bottom':
+      if (rtl) return isStart ? rlPlacement : lrPlacement;
+      return isStart ? lrPlacement : rlPlacement;
+    case 'left':
+    case 'right':
+      return isStart ? tbPlacement : btPlacement;
+    default:
+      return [];
+  }
+}
+function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
+  const alignment = getAlignment(placement);
+  let list = getSideList(getSide(placement), direction === 'start', rtl);
+  if (alignment) {
+    list = list.map(side => side + "-" + alignment);
+    if (flipAlignment) {
+      list = list.concat(list.map(getOppositeAlignmentPlacement));
+    }
+  }
+  return list;
+}
+function getOppositePlacement(placement) {
+  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);
+}
+function expandPaddingObject(padding) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...padding
+  };
+}
+function getPaddingObject(padding) {
+  return typeof padding !== 'number' ? expandPaddingObject(padding) : {
+    top: padding,
+    right: padding,
+    bottom: padding,
+    left: padding
+  };
+}
+function rectToClientRect(rect) {
+  const {
+    x,
+    y,
+    width,
+    height
+  } = rect;
+  return {
+    width,
+    height,
+    top: y,
+    left: x,
+    right: x + width,
+    bottom: y + height,
+    x,
+    y
+  };
+}
+
 var isClient$1 = typeof document !== 'undefined';
 
 var noop$1 = function noop() {};
@@ -8784,10 +8918,10 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
     reference,
     floating
   } = _ref;
-  const sideAxis = floatingUi_utils.getSideAxis(placement);
-  const alignmentAxis = floatingUi_utils.getAlignmentAxis(placement);
-  const alignLength = floatingUi_utils.getAxisLength(alignmentAxis);
-  const side = floatingUi_utils.getSide(placement);
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
   const isVertical = sideAxis === 'y';
   const commonX = reference.x + reference.width / 2 - floating.width / 2;
   const commonY = reference.y + reference.height / 2 - floating.height / 2;
@@ -8824,7 +8958,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (floatingUi_utils.getAlignment(placement)) {
+  switch (getAlignment(placement)) {
     case 'start':
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
@@ -8953,11 +9087,11 @@ async function detectOverflow(state, options) {
     elementContext = 'floating',
     altBoundary = false,
     padding = 0
-  } = floatingUi_utils.evaluate(options, state);
-  const paddingObject = floatingUi_utils.getPaddingObject(padding);
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
   const altContext = elementContext === 'floating' ? 'reference' : 'floating';
   const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = floatingUi_utils.rectToClientRect(await platform.getClippingRect({
+  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
     element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
     boundary,
     rootBoundary,
@@ -8977,7 +9111,7 @@ async function detectOverflow(state, options) {
     x: 1,
     y: 1
   };
-  const elementClientRect = floatingUi_utils.rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements,
     rect,
     offsetParent,
@@ -9013,17 +9147,17 @@ const arrow$3 = options => ({
     const {
       element,
       padding = 0
-    } = floatingUi_utils.evaluate(options, state) || {};
+    } = evaluate(options, state) || {};
     if (element == null) {
       return {};
     }
-    const paddingObject = floatingUi_utils.getPaddingObject(padding);
+    const paddingObject = getPaddingObject(padding);
     const coords = {
       x,
       y
     };
-    const axis = floatingUi_utils.getAlignmentAxis(placement);
-    const length = floatingUi_utils.getAxisLength(axis);
+    const axis = getAlignmentAxis(placement);
+    const length = getAxisLength(axis);
     const arrowDimensions = await platform.getDimensions(element);
     const isYAxis = axis === 'y';
     const minProp = isYAxis ? 'top' : 'left';
@@ -9043,21 +9177,21 @@ const arrow$3 = options => ({
     // If the padding is large enough that it causes the arrow to no longer be
     // centered, modify the padding so that it is centered.
     const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
-    const minPadding = floatingUi_utils.min(paddingObject[minProp], largestPossiblePadding);
-    const maxPadding = floatingUi_utils.min(paddingObject[maxProp], largestPossiblePadding);
+    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
 
     // Make sure the arrow doesn't overflow the floating element if the center
     // point is outside the floating element's bounds.
     const min$1 = minPadding;
     const max = clientSize - arrowDimensions[length] - maxPadding;
     const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
-    const offset = floatingUi_utils.clamp(min$1, center, max);
+    const offset = clamp(min$1, center, max);
 
     // If the reference is small enough that the arrow's padding causes it to
     // to point to nothing for an aligned placement, adjust the offset of the
     // floating element itself. To ensure `shift()` continues to take action,
     // a single reset is performed when this is true.
-    const shouldAddOffset = !middlewareData.arrow && floatingUi_utils.getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
     const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
@@ -9104,7 +9238,7 @@ const flip$2 = function (options) {
         fallbackAxisSideDirection = 'none',
         flipAlignment = true,
         ...detectOverflowOptions
-      } = floatingUi_utils.evaluate(options, state);
+      } = evaluate(options, state);
 
       // If a reset by the arrow was caused due to an alignment offset being
       // added, we should skip any logic now since `flip()` has already done its
@@ -9113,14 +9247,14 @@ const flip$2 = function (options) {
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
-      const side = floatingUi_utils.getSide(placement);
-      const initialSideAxis = floatingUi_utils.getSideAxis(initialPlacement);
-      const isBasePlacement = floatingUi_utils.getSide(initialPlacement) === initialPlacement;
+      const side = getSide(placement);
+      const initialSideAxis = getSideAxis(initialPlacement);
+      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
       const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [floatingUi_utils.getOppositePlacement(initialPlacement)] : floatingUi_utils.getExpandedPlacements(initialPlacement));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
       const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...floatingUi_utils.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
       const overflow = await detectOverflow(state, detectOverflowOptions);
@@ -9130,7 +9264,7 @@ const flip$2 = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const sides = floatingUi_utils.getAlignmentSides(placement, rects, rtl);
+        const sides = getAlignmentSides(placement, rects, rtl);
         overflows.push(overflow[sides[0]], overflow[sides[1]]);
       }
       overflowsData = [...overflowsData, {
@@ -9144,11 +9278,11 @@ const flip$2 = function (options) {
         const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
         const nextPlacement = placements[nextIndex];
         if (nextPlacement) {
-          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== floatingUi_utils.getSideAxis(nextPlacement) : false;
+          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== getSideAxis(nextPlacement) : false;
           if (!ignoreCrossAxisOverflow ||
           // We leave the current main axis only if every placement on that axis
           // overflows the main axis.
-          overflowsData.every(d => floatingUi_utils.getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+          overflowsData.every(d => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -9174,7 +9308,7 @@ const flip$2 = function (options) {
                 var _overflowsData$filter2;
                 const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
                   if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = floatingUi_utils.getSideAxis(d.placement);
+                    const currentSideAxis = getSideAxis(d.placement);
                     return currentSideAxis === initialSideAxis ||
                     // Create a bias to the `y` side axis due to horizontal
                     // reading directions favoring greater width.
@@ -9217,12 +9351,12 @@ async function convertValueToCoords(state, options) {
     elements
   } = state;
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-  const side = floatingUi_utils.getSide(placement);
-  const alignment = floatingUi_utils.getAlignment(placement);
-  const isVertical = floatingUi_utils.getSideAxis(placement) === 'y';
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === 'y';
   const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = floatingUi_utils.evaluate(options, state);
+  const rawValue = evaluate(options, state);
 
   // eslint-disable-next-line prefer-const
   let {
@@ -9300,7 +9434,7 @@ function getCssDimensions(element) {
   const hasOffset = isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
+  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -9319,7 +9453,7 @@ function unwrapElement(element) {
 function getScale(element) {
   const domElement = unwrapElement(element);
   if (!isHTMLElement(domElement)) {
-    return floatingUi_utils.createCoords(1);
+    return createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
   const {
@@ -9327,8 +9461,8 @@ function getScale(element) {
     height,
     $
   } = getCssDimensions(domElement);
-  let x = ($ ? floatingUi_utils.round(rect.width) : rect.width) / width;
-  let y = ($ ? floatingUi_utils.round(rect.height) : rect.height) / height;
+  let x = ($ ? round(rect.width) : rect.width) / width;
+  let y = ($ ? round(rect.height) : rect.height) / height;
 
   // 0, NaN, or Infinity should always fallback to 1.
 
@@ -9344,7 +9478,7 @@ function getScale(element) {
   };
 }
 
-const noOffsets = /*#__PURE__*/floatingUi_utils.createCoords(0);
+const noOffsets = /*#__PURE__*/createCoords(0);
 function getVisualOffsets(element) {
   const win = getWindow(element);
   if (!isWebKit() || !win.visualViewport) {
@@ -9374,7 +9508,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   }
   const clientRect = element.getBoundingClientRect();
   const domElement = unwrapElement(element);
-  let scale = floatingUi_utils.createCoords(1);
+  let scale = createCoords(1);
   if (includeScale) {
     if (offsetParent) {
       if (isElement(offsetParent)) {
@@ -9384,7 +9518,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       scale = getScale(element);
     }
   }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : floatingUi_utils.createCoords(0);
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
   let x = (clientRect.left + visualOffsets.x) / scale.x;
   let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
@@ -9410,7 +9544,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       currentIFrame = getFrameElement(currentWin);
     }
   }
-  return floatingUi_utils.rectToClientRect({
+  return rectToClientRect({
     width,
     height,
     x,
@@ -9455,8 +9589,8 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  let scale = floatingUi_utils.createCoords(1);
-  const offsets = floatingUi_utils.createCoords(0);
+  let scale = createCoords(1);
+  const offsets = createCoords(0);
   const isOffsetParentAnElement = isHTMLElement(offsetParent);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
     if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
@@ -9469,7 +9603,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -9488,12 +9622,12 @@ function getDocumentRect(element) {
   const html = getDocumentElement(element);
   const scroll = getNodeScroll(element);
   const body = element.ownerDocument.body;
-  const width = floatingUi_utils.max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = floatingUi_utils.max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
+  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
   let x = -scroll.scrollLeft + getWindowScrollBarX(element);
   const y = -scroll.scrollTop;
   if (getComputedStyle$1(body).direction === 'rtl') {
-    x += floatingUi_utils.max(html.clientWidth, body.clientWidth) - width;
+    x += max(html.clientWidth, body.clientWidth) - width;
   }
   return {
     width,
@@ -9556,7 +9690,7 @@ function getInnerBoundingClientRect(element, strategy) {
   const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');
   const top = clientRect.top + element.clientTop;
   const left = clientRect.left + element.clientLeft;
-  const scale = isHTMLElement(element) ? getScale(element) : floatingUi_utils.createCoords(1);
+  const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
   const width = element.clientWidth * scale.x;
   const height = element.clientHeight * scale.y;
   const x = left * scale.x;
@@ -9585,7 +9719,7 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
       height: clippingAncestor.height
     };
   }
-  return floatingUi_utils.rectToClientRect(rect);
+  return rectToClientRect(rect);
 }
 function hasFixedPositionAncestor(element, stopNode) {
   const parentNode = getParentNode(element);
@@ -9643,10 +9777,10 @@ function getClippingRect(_ref) {
   const firstClippingAncestor = clippingAncestors[0];
   const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
     const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-    accRect.top = floatingUi_utils.max(rect.top, accRect.top);
-    accRect.right = floatingUi_utils.min(rect.right, accRect.right);
-    accRect.bottom = floatingUi_utils.min(rect.bottom, accRect.bottom);
-    accRect.left = floatingUi_utils.max(rect.left, accRect.left);
+    accRect.top = max(rect.top, accRect.top);
+    accRect.right = min(rect.right, accRect.right);
+    accRect.bottom = min(rect.bottom, accRect.bottom);
+    accRect.left = max(rect.left, accRect.left);
     return accRect;
   }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
   return {
@@ -9677,7 +9811,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const offsets = floatingUi_utils.createCoords(0);
+  const offsets = createCoords(0);
 
   // If the <body> scrollbar appears on the left (e.g. RTL systems). Use
   // Firefox with layout.scrollbar.side = 3 in about:config to test this.
@@ -9699,7 +9833,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
   if (isFixed && !isOffsetParentAnElement && documentElement) {
     setLeftRTLScrollbarOffset();
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
   const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
   const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
   return {
@@ -9828,14 +9962,14 @@ function observeMove(element, onMove) {
     if (!width || !height) {
       return;
     }
-    const insetTop = floatingUi_utils.floor(top);
-    const insetRight = floatingUi_utils.floor(root.clientWidth - (left + width));
-    const insetBottom = floatingUi_utils.floor(root.clientHeight - (top + height));
-    const insetLeft = floatingUi_utils.floor(left);
+    const insetTop = floor(top);
+    const insetRight = floor(root.clientWidth - (left + width));
+    const insetBottom = floor(root.clientHeight - (top + height));
+    const insetLeft = floor(left);
     const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
     const options = {
       rootMargin,
-      threshold: floatingUi_utils.max(0, floatingUi_utils.min(1, threshold)) || 1
+      threshold: max(0, min(1, threshold)) || 1
     };
     let isFirstUpdate = true;
     function handleObserve(entries) {
@@ -11566,10 +11700,10 @@ function getEffectiveMinDate(_a) {
     var minDate = _a.minDate, includeDates = _a.includeDates;
     if (includeDates && minDate) {
         var minDates = includeDates.filter(function (includeDate) { return differenceInCalendarDays(includeDate, minDate) >= 0; });
-        return min(minDates);
+        return min$1(minDates);
     }
     else if (includeDates) {
-        return min(includeDates);
+        return min$1(includeDates);
     }
     else {
         return minDate;
@@ -11579,10 +11713,10 @@ function getEffectiveMaxDate(_a) {
     var maxDate = _a.maxDate, includeDates = _a.includeDates;
     if (includeDates && maxDate) {
         var maxDates = includeDates.filter(function (includeDate) { return differenceInCalendarDays(includeDate, maxDate) <= 0; });
-        return max(maxDates);
+        return max$1(maxDates);
     }
     else if (includeDates) {
-        return max(includeDates);
+        return max$1(includeDates);
     }
     else {
         return maxDate;

package/dist/cjs/{fthry_index.C_3RykNd.js → fthry_index.E_PMR0Yl.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index$1 = require('./fthry_index.Di_2sd1H.js');
+var index$1 = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
 require('react/jsx-runtime');
 require('react-dom/client');

package/dist/cjs/{fthry_index.CJZrrJii.js → fthry_index.fleNYFAW.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
 require('react/jsx-runtime');
 require('react-dom/client');

package/dist/cjs/{fthry_index.DX-1RJ2S.js → fthry_index.hn3nWnc7.js}

@@ -1,16 +1,16 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
-var FormControl = require('./fthry_FormControl.C6Rjgaho.js');
-var index$1 = require('./fthry_index.CioaVxCu.js');
-var InlineTooltip = require('./fthry_InlineTooltip.7d1XAj6X.js');
-var useSalesforceSync = require('./fthry_useSalesforceSync.DuaHbK7s.js');
+var FormControl = require('./fthry_FormControl.BkRkEOPV.js');
+var index$1 = require('./fthry_index.BYMaOURT.js');
+var InlineTooltip = require('./fthry_InlineTooltip.CbVeAbj-.js');
+var useSalesforceSync = require('./fthry_useSalesforceSync.DURMJ7-O.js');
 require('react/jsx-runtime');
 require('react-dom/client');
 require('jszip');
 require('react-dom');
-require('./fthry_Overlay.Bw-JWkvN.js');
+require('./fthry_Overlay.zp3MDZez.js');
 
 var applyRadioGroupStyles = function (element, responsiveStyles) {
     responsiveStyles.addTargets('radioGroup');

package/dist/cjs/{fthry_index.NNL4lQSw.js → fthry_index.sQV37Gt2.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 
 var propTypes = {exports: {}};
 

package/dist/cjs/{fthry_input.DWFkBuAl.js → fthry_input.BhfAe7t1.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var React = require('react');
-var index = require('./fthry_index.NNL4lQSw.js');
+var index = require('./fthry_index.sQV37Gt2.js');
 
 /** Checks if value is string */
 function isString(str) {

package/dist/cjs/{fthry_script.BVLKs7Gs.js → fthry_script.iSzGaCwW.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 
 function _mergeNamespaces(n, m) {
   m.forEach(function (e) {

package/dist/cjs/{fthry_styles.B-tC_Abq.js → fthry_styles.CKZy9WDb.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var React = require('react');
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 var ReactDOM = require('react-dom');
 
 function _interopNamespaceDefault(e) {

package/dist/cjs/{fthry_useElementSize.BepGSP1Z.js → fthry_useElementSize.CUMmUgEh.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
 
 function useElementSize(anchorRef) {

package/dist/cjs/{fthry_useSalesforceSync.DuaHbK7s.js → fthry_useSalesforceSync.DURMJ7-O.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 var React = require('react');
 
 function useSalesforceSync(salesforceSync, editMode) {

package/dist/cjs/{fthry_webfontloader.D1tv1rM2.js → fthry_webfontloader.C04VodQo.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./fthry_index.Di_2sd1H.js');
+var index = require('./fthry_index.CtdngFQd.js');
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {

package/dist/cjs/index.d.ts

@@ -54,6 +54,13 @@ declare function renderAt(elementId: any, props: FormProps, loginEnabled?: boole
     runAIExtraction: (extractionId: string, options?: {
         waitForCompletion: boolean;
     }, pages?: import("./utils/internalState").PageSelectionInput | undefined) => Promise<Record<string, string>>;
+    forwardInboxEmail: (options: {
+        emails?: string[] | undefined;
+        emailGroup?: string | undefined;
+    }) => Promise<{
+        ok: boolean;
+        error?: string | undefined;
+    }>;
     setCalendlyUrl: (url: string) => void;
     applyAlloyJourney: (journeyToken: string, entities: import("./utils/internalState").AlloyEntities) => Promise<{
         ok: boolean;