@feathery/react 2.12.1 → 2.12.2

package/dist/cjs/{fthry_index.B9nSbifR.js → fthry_index.S5WoB9-i.js}

@@ -1,14 +1,14 @@
 'use strict';
 
-var index$1 = require('./fthry_index.BnZd5CLv.js');
+var index$1 = require('./fthry_index.Di_2sd1H.js');
 var React = require('react');
-var Placeholder = require('./fthry_Placeholder.B8GeFQZR.js');
-var InlineTooltip = require('./fthry_InlineTooltip.DR7bLXGa.js');
+var Placeholder = require('./fthry_Placeholder.DExePn4A.js');
+var InlineTooltip = require('./fthry_InlineTooltip.7d1XAj6X.js');
 require('react/jsx-runtime');
 require('react-dom/client');
 require('jszip');
 require('react-dom');
-require('./fthry_Overlay.CrZjxgT8.js');
+require('./fthry_Overlay.Bw-JWkvN.js');
 
 function TextArea(_a) {
     var element = _a.element, responsiveStyles = _a.responsiveStyles, fieldLabel = _a.fieldLabel, _b = _a.elementProps, elementProps = _b === void 0 ? {} : _b, _c = _a.required, required = _c === void 0 ? false : _c, _d = _a.disabled, disabled = _d === void 0 ? false : _d, editMode = _a.editMode, _e = _a.onChange, onChange = _e === void 0 ? function () { } : _e, _f = _a.setRef, setRef = _f === void 0 ? function () { } : _f, _g = _a.rawValue, rawValue = _g === void 0 ? '' : _g, inlineError = _a.inlineError, _h = _a.repeatIndex, repeatIndex = _h === void 0 ? null : _h, children = _a.children;

package/dist/cjs/{fthry_index.xPqRnN8F.js → fthry_index.YNi32Ez7.js}

@@ -1,16 +1,16 @@
 'use strict';
 
-var index$1 = require('./fthry_index.BnZd5CLv.js');
+var index$1 = require('./fthry_index.Di_2sd1H.js');
 var React = require('react');
-var FormControl = require('./fthry_FormControl.D9BJvVaJ.js');
-var index = require('./fthry_index.D9L4f3Pj.js');
-var InlineTooltip = require('./fthry_InlineTooltip.DR7bLXGa.js');
-var useSalesforceSync = require('./fthry_useSalesforceSync.CQ0w7bSH.js');
+var FormControl = require('./fthry_FormControl.C6Rjgaho.js');
+var index = require('./fthry_index.CioaVxCu.js');
+var InlineTooltip = require('./fthry_InlineTooltip.7d1XAj6X.js');
+var useSalesforceSync = require('./fthry_useSalesforceSync.DuaHbK7s.js');
 require('react/jsx-runtime');
 require('react-dom/client');
 require('jszip');
 require('react-dom');
-require('./fthry_Overlay.CrZjxgT8.js');
+require('./fthry_Overlay.Bw-JWkvN.js');
 
 var applyCheckboxGroupStyles = function (element, responsiveStyles) {
     responsiveStyles.addTargets('checkboxGroup');

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

@@ -1,16 +1,17 @@
 'use strict';
 
-var index$3 = require('./fthry_index.BnZd5CLv.js');
+var index$3 = require('./fthry_index.Di_2sd1H.js');
 var React = require('react');
-var Placeholder = require('./fthry_Placeholder.B8GeFQZR.js');
-var InlineTooltip = require('./fthry_InlineTooltip.DR7bLXGa.js');
+var Placeholder = require('./fthry_Placeholder.DExePn4A.js');
+var InlineTooltip = require('./fthry_InlineTooltip.7d1XAj6X.js');
 var ReactJSXRuntime = require('react/jsx-runtime');
 var ReactDOM = require('react-dom');
-var input = require('./fthry_input.B183IqBD.js');
+var floatingUi_utils = require('./fthry_floating-ui.utils.D2KLOgYj.js');
+var input = require('./fthry_input.DWFkBuAl.js');
 require('react-dom/client');
 require('jszip');
-require('./fthry_Overlay.CrZjxgT8.js');
-require('./fthry_index.dDIBqxIW.js');
+require('./fthry_Overlay.Bw-JWkvN.js');
+require('./fthry_index.NNL4lQSw.js');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -2020,7 +2021,7 @@ function addYears(date, amount) {
  * ])
  * //=> Sun Jul 02 1995 00:00:00
  */
-function max$1(dates) {
+function max(dates) {
   let result;
   dates.forEach(function (dirtyDate) {
     const currentDate = toDate(dirtyDate);
@@ -2061,7 +2062,7 @@ function max$1(dates) {
  * ])
  * //=> Wed Feb 11 1987 00:00:00
  */
-function min$1(dates) {
+function min(dates) {
   let result;
 
   dates.forEach((dirtyDate) => {
@@ -8750,141 +8751,6 @@ 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() {};
@@ -8918,10 +8784,10 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
     reference,
     floating
   } = _ref;
-  const sideAxis = getSideAxis(placement);
-  const alignmentAxis = getAlignmentAxis(placement);
-  const alignLength = getAxisLength(alignmentAxis);
-  const side = getSide(placement);
+  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 isVertical = sideAxis === 'y';
   const commonX = reference.x + reference.width / 2 - floating.width / 2;
   const commonY = reference.y + reference.height / 2 - floating.height / 2;
@@ -8958,7 +8824,7 @@ function computeCoordsFromPlacement(_ref, placement, rtl) {
         y: reference.y
       };
   }
-  switch (getAlignment(placement)) {
+  switch (floatingUi_utils.getAlignment(placement)) {
     case 'start':
       coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
       break;
@@ -9087,11 +8953,11 @@ async function detectOverflow(state, options) {
     elementContext = 'floating',
     altBoundary = false,
     padding = 0
-  } = evaluate(options, state);
-  const paddingObject = getPaddingObject(padding);
+  } = floatingUi_utils.evaluate(options, state);
+  const paddingObject = floatingUi_utils.getPaddingObject(padding);
   const altContext = elementContext === 'floating' ? 'reference' : 'floating';
   const element = elements[altBoundary ? altContext : elementContext];
-  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+  const clippingClientRect = floatingUi_utils.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,
@@ -9111,7 +8977,7 @@ async function detectOverflow(state, options) {
     x: 1,
     y: 1
   };
-  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+  const elementClientRect = floatingUi_utils.rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
     elements,
     rect,
     offsetParent,
@@ -9147,17 +9013,17 @@ const arrow$3 = options => ({
     const {
       element,
       padding = 0
-    } = evaluate(options, state) || {};
+    } = floatingUi_utils.evaluate(options, state) || {};
     if (element == null) {
       return {};
     }
-    const paddingObject = getPaddingObject(padding);
+    const paddingObject = floatingUi_utils.getPaddingObject(padding);
     const coords = {
       x,
       y
     };
-    const axis = getAlignmentAxis(placement);
-    const length = getAxisLength(axis);
+    const axis = floatingUi_utils.getAlignmentAxis(placement);
+    const length = floatingUi_utils.getAxisLength(axis);
     const arrowDimensions = await platform.getDimensions(element);
     const isYAxis = axis === 'y';
     const minProp = isYAxis ? 'top' : 'left';
@@ -9177,21 +9043,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 = min(paddingObject[minProp], largestPossiblePadding);
-    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
+    const minPadding = floatingUi_utils.min(paddingObject[minProp], largestPossiblePadding);
+    const maxPadding = floatingUi_utils.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 = clamp(min$1, center, max);
+    const offset = floatingUi_utils.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 && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
+    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 alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;
     return {
       [axis]: coords[axis] + alignmentOffset,
@@ -9238,7 +9104,7 @@ const flip$2 = function (options) {
         fallbackAxisSideDirection = 'none',
         flipAlignment = true,
         ...detectOverflowOptions
-      } = evaluate(options, state);
+      } = floatingUi_utils.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
@@ -9247,14 +9113,14 @@ const flip$2 = function (options) {
       if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
         return {};
       }
-      const side = getSide(placement);
-      const initialSideAxis = getSideAxis(initialPlacement);
-      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
+      const side = floatingUi_utils.getSide(placement);
+      const initialSideAxis = floatingUi_utils.getSideAxis(initialPlacement);
+      const isBasePlacement = floatingUi_utils.getSide(initialPlacement) === initialPlacement;
       const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
+      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [floatingUi_utils.getOppositePlacement(initialPlacement)] : floatingUi_utils.getExpandedPlacements(initialPlacement));
       const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';
       if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {
-        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
+        fallbackPlacements.push(...floatingUi_utils.getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
       }
       const placements = [initialPlacement, ...fallbackPlacements];
       const overflow = await detectOverflow(state, detectOverflowOptions);
@@ -9264,7 +9130,7 @@ const flip$2 = function (options) {
         overflows.push(overflow[side]);
       }
       if (checkCrossAxis) {
-        const sides = getAlignmentSides(placement, rects, rtl);
+        const sides = floatingUi_utils.getAlignmentSides(placement, rects, rtl);
         overflows.push(overflow[sides[0]], overflow[sides[1]]);
       }
       overflowsData = [...overflowsData, {
@@ -9278,11 +9144,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 !== getSideAxis(nextPlacement) : false;
+          const ignoreCrossAxisOverflow = checkCrossAxis === 'alignment' ? initialSideAxis !== floatingUi_utils.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 => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
+          overflowsData.every(d => floatingUi_utils.getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) {
             // Try next placement and re-run the lifecycle.
             return {
               data: {
@@ -9308,7 +9174,7 @@ const flip$2 = function (options) {
                 var _overflowsData$filter2;
                 const placement = (_overflowsData$filter2 = overflowsData.filter(d => {
                   if (hasFallbackAxisSideDirection) {
-                    const currentSideAxis = getSideAxis(d.placement);
+                    const currentSideAxis = floatingUi_utils.getSideAxis(d.placement);
                     return currentSideAxis === initialSideAxis ||
                     // Create a bias to the `y` side axis due to horizontal
                     // reading directions favoring greater width.
@@ -9351,12 +9217,12 @@ async function convertValueToCoords(state, options) {
     elements
   } = state;
   const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
-  const side = getSide(placement);
-  const alignment = getAlignment(placement);
-  const isVertical = getSideAxis(placement) === 'y';
+  const side = floatingUi_utils.getSide(placement);
+  const alignment = floatingUi_utils.getAlignment(placement);
+  const isVertical = floatingUi_utils.getSideAxis(placement) === 'y';
   const mainAxisMulti = originSides.has(side) ? -1 : 1;
   const crossAxisMulti = rtl && isVertical ? -1 : 1;
-  const rawValue = evaluate(options, state);
+  const rawValue = floatingUi_utils.evaluate(options, state);
 
   // eslint-disable-next-line prefer-const
   let {
@@ -9434,7 +9300,7 @@ function getCssDimensions(element) {
   const hasOffset = isHTMLElement(element);
   const offsetWidth = hasOffset ? element.offsetWidth : width;
   const offsetHeight = hasOffset ? element.offsetHeight : height;
-  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
+  const shouldFallback = floatingUi_utils.round(width) !== offsetWidth || floatingUi_utils.round(height) !== offsetHeight;
   if (shouldFallback) {
     width = offsetWidth;
     height = offsetHeight;
@@ -9453,7 +9319,7 @@ function unwrapElement(element) {
 function getScale(element) {
   const domElement = unwrapElement(element);
   if (!isHTMLElement(domElement)) {
-    return createCoords(1);
+    return floatingUi_utils.createCoords(1);
   }
   const rect = domElement.getBoundingClientRect();
   const {
@@ -9461,8 +9327,8 @@ function getScale(element) {
     height,
     $
   } = getCssDimensions(domElement);
-  let x = ($ ? round(rect.width) : rect.width) / width;
-  let y = ($ ? round(rect.height) : rect.height) / height;
+  let x = ($ ? floatingUi_utils.round(rect.width) : rect.width) / width;
+  let y = ($ ? floatingUi_utils.round(rect.height) : rect.height) / height;
 
   // 0, NaN, or Infinity should always fallback to 1.
 
@@ -9478,7 +9344,7 @@ function getScale(element) {
   };
 }
 
-const noOffsets = /*#__PURE__*/createCoords(0);
+const noOffsets = /*#__PURE__*/floatingUi_utils.createCoords(0);
 function getVisualOffsets(element) {
   const win = getWindow(element);
   if (!isWebKit() || !win.visualViewport) {
@@ -9508,7 +9374,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
   }
   const clientRect = element.getBoundingClientRect();
   const domElement = unwrapElement(element);
-  let scale = createCoords(1);
+  let scale = floatingUi_utils.createCoords(1);
   if (includeScale) {
     if (offsetParent) {
       if (isElement(offsetParent)) {
@@ -9518,7 +9384,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       scale = getScale(element);
     }
   }
-  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
+  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : floatingUi_utils.createCoords(0);
   let x = (clientRect.left + visualOffsets.x) / scale.x;
   let y = (clientRect.top + visualOffsets.y) / scale.y;
   let width = clientRect.width / scale.x;
@@ -9544,7 +9410,7 @@ function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetPar
       currentIFrame = getFrameElement(currentWin);
     }
   }
-  return rectToClientRect({
+  return floatingUi_utils.rectToClientRect({
     width,
     height,
     x,
@@ -9589,8 +9455,8 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  let scale = createCoords(1);
-  const offsets = createCoords(0);
+  let scale = floatingUi_utils.createCoords(1);
+  const offsets = floatingUi_utils.createCoords(0);
   const isOffsetParentAnElement = isHTMLElement(offsetParent);
   if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
     if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
@@ -9603,7 +9469,7 @@ function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
       offsets.y = offsetRect.y + offsetParent.clientTop;
     }
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
   return {
     width: rect.width * scale.x,
     height: rect.height * scale.y,
@@ -9622,12 +9488,12 @@ function getDocumentRect(element) {
   const html = getDocumentElement(element);
   const scroll = getNodeScroll(element);
   const body = element.ownerDocument.body;
-  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
-  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
+  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);
   let x = -scroll.scrollLeft + getWindowScrollBarX(element);
   const y = -scroll.scrollTop;
   if (getComputedStyle$1(body).direction === 'rtl') {
-    x += max(html.clientWidth, body.clientWidth) - width;
+    x += floatingUi_utils.max(html.clientWidth, body.clientWidth) - width;
   }
   return {
     width,
@@ -9690,7 +9556,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) : createCoords(1);
+  const scale = isHTMLElement(element) ? getScale(element) : floatingUi_utils.createCoords(1);
   const width = element.clientWidth * scale.x;
   const height = element.clientHeight * scale.y;
   const x = left * scale.x;
@@ -9719,7 +9585,7 @@ function getClientRectFromClippingAncestor(element, clippingAncestor, strategy)
       height: clippingAncestor.height
     };
   }
-  return rectToClientRect(rect);
+  return floatingUi_utils.rectToClientRect(rect);
 }
 function hasFixedPositionAncestor(element, stopNode) {
   const parentNode = getParentNode(element);
@@ -9777,10 +9643,10 @@ function getClippingRect(_ref) {
   const firstClippingAncestor = clippingAncestors[0];
   const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
     const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
-    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);
+    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);
     return accRect;
   }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
   return {
@@ -9811,7 +9677,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
     scrollLeft: 0,
     scrollTop: 0
   };
-  const offsets = createCoords(0);
+  const offsets = floatingUi_utils.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.
@@ -9833,7 +9699,7 @@ function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
   if (isFixed && !isOffsetParentAnElement && documentElement) {
     setLeftRTLScrollbarOffset();
   }
-  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0);
+  const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : floatingUi_utils.createCoords(0);
   const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x;
   const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y;
   return {
@@ -9962,14 +9828,14 @@ function observeMove(element, onMove) {
     if (!width || !height) {
       return;
     }
-    const insetTop = floor(top);
-    const insetRight = floor(root.clientWidth - (left + width));
-    const insetBottom = floor(root.clientHeight - (top + height));
-    const insetLeft = floor(left);
+    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 rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
     const options = {
       rootMargin,
-      threshold: max(0, min(1, threshold)) || 1
+      threshold: floatingUi_utils.max(0, floatingUi_utils.min(1, threshold)) || 1
     };
     let isFirstUpdate = true;
     function handleObserve(entries) {
@@ -11700,10 +11566,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$1(minDates);
+        return min(minDates);
     }
     else if (includeDates) {
-        return min$1(includeDates);
+        return min(includeDates);
     }
     else {
         return minDate;
@@ -11713,10 +11579,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$1(maxDates);
+        return max(maxDates);
     }
     else if (includeDates) {
-        return max$1(includeDates);
+        return max(includeDates);
     }
     else {
         return maxDate;

package/dist/cjs/{fthry_index.MtnDTtkS.js → fthry_index.wQoLwNSA.js}

@@ -1,9 +1,9 @@
 'use strict';
 
-var index = require('./fthry_index.BnZd5CLv.js');
+var index = require('./fthry_index.Di_2sd1H.js');
 var React = require('react');
-var Overlay = require('./fthry_Overlay.CrZjxgT8.js');
-var index$1 = require('./fthry_index.D9L4f3Pj.js');
+var Overlay = require('./fthry_Overlay.Bw-JWkvN.js');
+var index$1 = require('./fthry_index.CioaVxCu.js');
 require('react/jsx-runtime');
 require('react-dom/client');
 require('jszip');

package/dist/cjs/{fthry_index.BIdvmzZQ.js → fthry_index.xtJFp2c_.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var index = require('./fthry_index.BnZd5CLv.js');
+var index = require('./fthry_index.Di_2sd1H.js');
 var React = require('react');
-var index$1 = require('./fthry_index.dDIBqxIW.js');
+var index$1 = require('./fthry_index.NNL4lQSw.js');
 require('react/jsx-runtime');
 require('react-dom/client');
 require('jszip');
@@ -1435,7 +1435,7 @@ function SignatureField(_a) {
     React.useEffect(function () {
         if (!global.webfontloaderPromise)
             global.webfontloaderPromise = Promise.resolve().then(function () { return require(
-            /* webpackChunkName: "webfontloader" */ './fthry_webfontloader.B6879vMH.js'); }).then(function (n) { return n.webfontloader; });
+            /* webpackChunkName: "webfontloader" */ './fthry_webfontloader.D1tv1rM2.js'); }).then(function (n) { return n.webfontloader; });
         global.webfontloaderPromise.then(function (WebFont) {
             WebFont.load({ google: { families: ['La Belle Aurore'] } });
         });

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

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

package/dist/cjs/fthry_objectWithoutPropertiesLoose.BeCY0BVl.js

@@ -0,0 +1,32 @@
+'use strict';
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+
+exports._extends = _extends;
+exports._objectWithoutPropertiesLoose = _objectWithoutPropertiesLoose;