dune-react 0.0.43 → 0.0.44

package/dist/components/puck-core/core/props/index.js

@@ -2,6 +2,7 @@ import { buttonsField, badgeField } from "./interactive.js";
 import { actionDefaults, actionField, buttonDefaults, buttonField, iconField, resolveActionUrl } from "./interactive.js";
 import { descriptionField, headingField, featuresField } from "./content.js";
 import { cardField, cardsField } from "./content.js";
+import { getPlaceholderMediaUrl, media16x9Placeholder, media1x1Placeholder, media9x16Placeholder, mediaField, mediasField } from "./media.js";
 const contentFields = {
   heading: headingField,
   description: descriptionField,
@@ -28,7 +29,13 @@ export {
   contentFieldsWithFeatures,
   descriptionField,
   featuresField,
+  getPlaceholderMediaUrl,
   headingField,
   iconField,
+  media16x9Placeholder,
+  media1x1Placeholder,
+  media9x16Placeholder,
+  mediaField,
+  mediasField,
   resolveActionUrl
 };

package/dist/components/shadcn/slider.js

@@ -34,7 +34,7 @@ function Slider({
           Slider$1.Track,
           {
             "data-slot": "slider-track",
-            className: "relative grow overflow-hidden rounded-full bg-muted select-none data-horizontal:h-1 data-horizontal:w-full data-vertical:h-full data-vertical:w-1",
+            className: "relative grow overflow-hidden rounded-full bg-muted-foreground/20 select-none data-horizontal:h-1 data-horizontal:w-full data-vertical:h-full data-vertical:w-1",
             children: /* @__PURE__ */ jsx(
               Slider$1.Indicator,
               {

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/algorithms/flipImageAlgorithm.js

@@ -0,0 +1,44 @@
+import { rotatePoint, getCenter, applyMove, diff, moveToPositionRestrictions } from "../service/utils.js";
+import { isInitializedState, getTransformedImageSize, getAreaPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "../state/copyState.js";
+function flipImageAlgorithm(state, settings, horizontal, vertical) {
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    var rotate = state.transforms.rotate;
+    var imageSize = getTransformedImageSize(state);
+    var changed = {
+      horizontal,
+      vertical
+    };
+    if (changed.horizontal || changed.vertical) {
+      var imageCenter = rotatePoint({
+        left: imageSize.width / 2,
+        top: imageSize.height / 2
+      }, -rotate);
+      var oldCenter = rotatePoint(getCenter(result.coordinates), -rotate);
+      var newCenter = rotatePoint({
+        left: changed.horizontal ? imageCenter.left - (oldCenter.left - imageCenter.left) : oldCenter.left,
+        top: changed.vertical ? imageCenter.top - (oldCenter.top - imageCenter.top) : oldCenter.top
+      }, rotate);
+      result.coordinates = applyMove(result.coordinates, diff(newCenter, getCenter(result.coordinates)));
+      oldCenter = rotatePoint(getCenter(result.visibleArea), -rotate);
+      newCenter = rotatePoint({
+        left: changed.horizontal ? imageCenter.left - (oldCenter.left - imageCenter.left) : oldCenter.left,
+        top: changed.vertical ? imageCenter.top - (oldCenter.top - imageCenter.top) : oldCenter.top
+      }, rotate);
+      result.visibleArea = applyMove(result.visibleArea, diff(newCenter, getCenter(result.visibleArea)));
+      result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+    }
+    if (changed.horizontal) {
+      result.transforms.flip.horizontal = !state.transforms.flip.horizontal;
+    }
+    if (changed.vertical) {
+      result.transforms.flip.vertical = !state.transforms.flip.vertical;
+    }
+    return result;
+  }
+  return state;
+}
+export {
+  flipImageAlgorithm
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/algorithms/moveCoordinatesAlgorithm.js

@@ -0,0 +1,8 @@
+import { applyMove, moveToPositionRestrictions } from "../service/utils.js";
+function moveCoordinatesAlgorithm(coordinates, directions, positionRestrictions) {
+  var movedCoordinates = applyMove(coordinates, directions);
+  return positionRestrictions ? moveToPositionRestrictions(movedCoordinates, positionRestrictions) : movedCoordinates;
+}
+export {
+  moveCoordinatesAlgorithm
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/algorithms/resizeCoordinatesAlgorithm.js

@@ -0,0 +1,291 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { ALL_DIRECTIONS, HORIZONTAL_DIRECTIONS, VERTICAL_DIRECTIONS } from "../constants/index.js";
+import { isGreater, isRoughlyEqual } from "../utils/index.js";
+import { applyMove, diff, moveToPositionRestrictions, applyDirections, ratio, getBrokenRatio, getIntersections, getOppositeSide } from "../service/utils.js";
+import { moveCoordinatesAlgorithm } from "./moveCoordinatesAlgorithm.js";
+function fitDirections(_a) {
+  var coordinates = _a.coordinates, directions = _a.directions, positionRestrictions = _a.positionRestrictions, sizeRestrictions = _a.sizeRestrictions, preserveRatio = _a.preserveRatio, allowedDirections = _a.allowedDirections, _b = _a.compensate, compensate = _b === void 0 ? true : _b;
+  var fittedDirections = __assign({}, directions);
+  var currentWidth = applyDirections(coordinates, fittedDirections).width;
+  var currentHeight = applyDirections(coordinates, fittedDirections).height;
+  if (currentWidth < 0) {
+    if (fittedDirections.left < 0 && fittedDirections.right < 0) {
+      fittedDirections.left = -(coordinates.width - sizeRestrictions.minWidth) / (fittedDirections.left / fittedDirections.right);
+      fittedDirections.right = -(coordinates.width - sizeRestrictions.minWidth) / (fittedDirections.right / fittedDirections.left);
+    } else if (fittedDirections.left < 0) {
+      fittedDirections.left = -(coordinates.width - sizeRestrictions.minWidth);
+    } else if (fittedDirections.right < 0) {
+      fittedDirections.right = -(coordinates.width - sizeRestrictions.minWidth);
+    }
+  }
+  if (currentHeight < 0) {
+    if (fittedDirections.top < 0 && fittedDirections.bottom < 0) {
+      fittedDirections.top = -(coordinates.height - sizeRestrictions.minHeight) / (fittedDirections.top / fittedDirections.bottom);
+      fittedDirections.bottom = -(coordinates.height - sizeRestrictions.minHeight) / (fittedDirections.bottom / fittedDirections.top);
+    } else if (fittedDirections.top < 0) {
+      fittedDirections.top = -(coordinates.height - sizeRestrictions.minHeight);
+    } else if (fittedDirections.bottom < 0) {
+      fittedDirections.bottom = -(coordinates.height - sizeRestrictions.minHeight);
+    }
+  }
+  var breaks = getIntersections(applyDirections(coordinates, fittedDirections), positionRestrictions);
+  var canBeCompensated = ALL_DIRECTIONS.every(function(direction) {
+    return !isGreater(breaks[getOppositeSide(direction)], 0) || allowedDirections[direction];
+  });
+  if (compensate && canBeCompensated) {
+    if (breaks.left && breaks.left > 0 && breaks.right === 0) {
+      fittedDirections.right += breaks.left;
+      fittedDirections.left -= breaks.left;
+    } else if (breaks.right && breaks.right > 0 && breaks.left === 0) {
+      fittedDirections.left += breaks.right;
+      fittedDirections.right -= breaks.right;
+    }
+    if (breaks.top && breaks.top > 0 && breaks.bottom === 0) {
+      fittedDirections.bottom += breaks.top;
+      fittedDirections.top -= breaks.top;
+    } else if (breaks.bottom && breaks.bottom > 0 && breaks.top === 0) {
+      fittedDirections.top += breaks.bottom;
+      fittedDirections.bottom -= breaks.bottom;
+    }
+    breaks = getIntersections(applyDirections(coordinates, fittedDirections), positionRestrictions);
+  }
+  var maxResize = {
+    width: Infinity,
+    height: Infinity,
+    left: Infinity,
+    right: Infinity,
+    top: Infinity,
+    bottom: Infinity
+  };
+  ALL_DIRECTIONS.forEach(function(direction) {
+    var intersection = breaks[direction];
+    if (intersection && fittedDirections[direction]) {
+      maxResize[direction] = Math.max(0, 1 - intersection / fittedDirections[direction]);
+    }
+  });
+  if (preserveRatio) {
+    var multiplier_1 = Math.min.apply(Math, ALL_DIRECTIONS.map(function(direction) {
+      return maxResize[direction];
+    }));
+    if (multiplier_1 !== Infinity) {
+      ALL_DIRECTIONS.forEach(function(direction) {
+        fittedDirections[direction] *= multiplier_1;
+      });
+    }
+  } else {
+    ALL_DIRECTIONS.forEach(function(direction) {
+      if (maxResize[direction] !== Infinity) {
+        fittedDirections[direction] *= maxResize[direction];
+      }
+    });
+  }
+  currentWidth = applyDirections(coordinates, fittedDirections).width;
+  currentHeight = applyDirections(coordinates, fittedDirections).height;
+  if (fittedDirections.right + fittedDirections.left) {
+    if (currentWidth > sizeRestrictions.maxWidth) {
+      maxResize.width = (sizeRestrictions.maxWidth - coordinates.width) / (fittedDirections.right + fittedDirections.left);
+    } else if (currentWidth < sizeRestrictions.minWidth) {
+      maxResize.width = (sizeRestrictions.minWidth - coordinates.width) / (fittedDirections.right + fittedDirections.left);
+    }
+  }
+  if (fittedDirections.bottom + fittedDirections.top) {
+    if (currentHeight > sizeRestrictions.maxHeight) {
+      maxResize.height = (sizeRestrictions.maxHeight - coordinates.height) / (fittedDirections.bottom + fittedDirections.top);
+    } else if (currentHeight < sizeRestrictions.minHeight) {
+      maxResize.height = (sizeRestrictions.minHeight - coordinates.height) / (fittedDirections.bottom + fittedDirections.top);
+    }
+  }
+  if (preserveRatio) {
+    var multiplier_2 = Math.min(maxResize.width, maxResize.height);
+    if (multiplier_2 !== Infinity) {
+      ALL_DIRECTIONS.forEach(function(direction) {
+        fittedDirections[direction] *= multiplier_2;
+      });
+    }
+  } else {
+    if (maxResize.width !== Infinity) {
+      HORIZONTAL_DIRECTIONS.forEach(function(direction) {
+        fittedDirections[direction] *= maxResize.width;
+      });
+    }
+    if (maxResize.height !== Infinity) {
+      VERTICAL_DIRECTIONS.forEach(function(direction) {
+        fittedDirections[direction] *= maxResize.height;
+      });
+    }
+  }
+  return fittedDirections;
+}
+function distributeOverlap(overlap, first, second) {
+  if (isRoughlyEqual(first + second, 0)) {
+    return overlap / 2;
+  } else if (isRoughlyEqual(first, 0)) {
+    return 0;
+  } else if (isRoughlyEqual(second, 0)) {
+    return overlap;
+  } else {
+    return overlap * Math.abs(first / (first + second));
+  }
+}
+function resizeCoordinatesAlgorithm(coordinates, directions, options, limitations) {
+  var aspectRatio = limitations.aspectRatio, positionRestrictions = limitations.positionRestrictions, sizeRestrictions = limitations.sizeRestrictions;
+  var actualCoordinates = __assign({}, coordinates);
+  directions = __assign({}, directions);
+  var allowedDirections = options.allowedDirections || {
+    left: true,
+    right: true,
+    bottom: true,
+    top: true
+  };
+  if (coordinates.width < sizeRestrictions.minWidth) {
+    directions.left = 0;
+    directions.right = 0;
+  }
+  if (coordinates.height < sizeRestrictions.minHeight) {
+    directions.top = 0;
+    directions.bottom = 0;
+  }
+  ALL_DIRECTIONS.forEach(function(direction) {
+    if (!allowedDirections[direction]) {
+      directions[direction] = 0;
+    }
+  });
+  directions = fitDirections({
+    coordinates: actualCoordinates,
+    directions,
+    sizeRestrictions,
+    positionRestrictions,
+    allowedDirections
+  });
+  var currentWidth = applyDirections(actualCoordinates, directions).width;
+  var currentHeight = applyDirections(actualCoordinates, directions).height;
+  var ratioBroken = options.preserveAspectRatio ? ratio(actualCoordinates) : getBrokenRatio(currentWidth / currentHeight, aspectRatio);
+  if (ratioBroken) {
+    var respectDirection = options.respectDirection;
+    if (respectDirection !== "width" && respectDirection !== "height") {
+      if (actualCoordinates.width >= actualCoordinates.height || ratioBroken === 1) {
+        respectDirection = "width";
+      } else {
+        respectDirection = "height";
+      }
+    }
+    if (respectDirection === "width") {
+      var overlapHeight = currentWidth / ratioBroken - actualCoordinates.height;
+      if (allowedDirections.top && allowedDirections.bottom) {
+        var top_1 = directions.top, bottom = directions.bottom;
+        directions.bottom = distributeOverlap(overlapHeight, bottom, top_1);
+        directions.top = distributeOverlap(overlapHeight, top_1, bottom);
+      } else if (allowedDirections.bottom) {
+        directions.bottom = overlapHeight;
+      } else if (allowedDirections.top) {
+        directions.top = overlapHeight;
+      } else if (allowedDirections.right) {
+        directions.right = 0;
+      } else if (allowedDirections.left) {
+        directions.left = 0;
+      }
+    } else if (respectDirection === "height") {
+      var overlapWidth = actualCoordinates.width - currentHeight * ratioBroken;
+      if (allowedDirections.left && allowedDirections.right) {
+        var left = directions.left, right = directions.right;
+        directions.left = -distributeOverlap(overlapWidth, left, right);
+        directions.right = -distributeOverlap(overlapWidth, right, left);
+      } else if (allowedDirections.left) {
+        directions.left = -overlapWidth;
+      } else if (allowedDirections.right) {
+        directions.right = -overlapWidth;
+      } else if (allowedDirections.top) {
+        directions.top = 0;
+      } else if (allowedDirections.bottom) {
+        directions.bottom = 0;
+      }
+    }
+    directions = fitDirections({
+      directions,
+      coordinates: actualCoordinates,
+      sizeRestrictions,
+      positionRestrictions,
+      preserveRatio: true,
+      compensate: options.compensate,
+      allowedDirections
+    });
+  }
+  currentWidth = applyDirections(actualCoordinates, directions).width;
+  currentHeight = applyDirections(actualCoordinates, directions).height;
+  ratioBroken = options.preserveAspectRatio ? ratio(actualCoordinates) : getBrokenRatio(currentWidth / currentHeight, aspectRatio);
+  if (ratioBroken && isGreater(Math.abs(ratioBroken - currentWidth / currentHeight), 0)) {
+    ALL_DIRECTIONS.forEach(function(direction) {
+      directions[direction] = 0;
+    });
+  }
+  return moveCoordinatesAlgorithm({
+    width: coordinates.width + directions.right + directions.left,
+    height: coordinates.height + directions.top + directions.bottom,
+    left: coordinates.left,
+    top: coordinates.top
+  }, {
+    left: -directions.left,
+    top: -directions.top
+  }, positionRestrictions);
+}
+function anchorToMassPoint(coordinates, anchor) {
+  var plainAnchor = anchor.toLowerCase();
+  return {
+    left: coordinates.left + coordinates.width * (plainAnchor.indexOf("west") !== -1 ? 1 : plainAnchor.indexOf("east") !== -1 ? 0 : 0.5),
+    top: coordinates.top + coordinates.height * (plainAnchor.indexOf("north") !== -1 ? 1 : plainAnchor.indexOf("south") !== -1 ? 0 : 0.5)
+  };
+}
+function anchorToAllowedDirections(anchor) {
+  var plainAnchor = anchor.toLowerCase();
+  return {
+    left: plainAnchor.indexOf("east") === -1,
+    top: plainAnchor.indexOf("south") === -1,
+    right: plainAnchor.indexOf("west") === -1,
+    bottom: plainAnchor.indexOf("north") === -1
+  };
+}
+function anchorMoveToResizeDirections(anchor, directions) {
+  var plainAnchor = anchor.toLowerCase();
+  var normalizedDirections = {
+    left: plainAnchor.indexOf("west") === -1 ? directions.left : -directions.left,
+    top: -directions.top,
+    right: directions.left,
+    bottom: directions.top
+  };
+  if (["north", "south", "center"].every(function(el) {
+    return plainAnchor.indexOf(el) === -1;
+  })) {
+    normalizedDirections.top = 0;
+    normalizedDirections.bottom = 0;
+  }
+  if (["west", "east", "center"].every(function(el) {
+    return plainAnchor.indexOf(el) === -1;
+  })) {
+    normalizedDirections.left = 0;
+    normalizedDirections.right = 0;
+  }
+  var allowedDirections = anchorToAllowedDirections(anchor);
+  ALL_DIRECTIONS.forEach(function(direction) {
+    if (!allowedDirections[direction]) {
+      normalizedDirections[direction] = 0;
+    }
+  });
+  return normalizedDirections;
+}
+function anchoredResizeCoordinatesAlgorithm(coordinates, anchor, directions, options, limitations) {
+  var reference = options.reference;
+  var resizeDirections = anchorMoveToResizeDirections(anchor, directions);
+  var allowedDirections = anchorToAllowedDirections(anchor);
+  var result = resizeCoordinatesAlgorithm(coordinates, resizeDirections, __assign(__assign({}, options), { allowedDirections }), limitations);
+  if (reference) {
+    result = applyMove(result, diff(anchorToMassPoint(reference, anchor), anchorToMassPoint(result, anchor)));
+  }
+  return moveToPositionRestrictions(result, limitations.positionRestrictions);
+}
+export {
+  anchorMoveToResizeDirections,
+  anchorToAllowedDirections,
+  anchoredResizeCoordinatesAlgorithm,
+  fitDirections,
+  resizeCoordinatesAlgorithm
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/algorithms/rotateImageAlgorithm.js

@@ -0,0 +1,38 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { isNumber } from "../utils/index.js";
+import { rotatePoint, getCenter, diff, resizeToSizeRestrictions, moveToPositionRestrictions, applyMove } from "../service/utils.js";
+import { mergeSizeRestrictions } from "../service/sizeRestrictions.js";
+import { isInitializedState, getTransformedImageSize, getAspectRatio, getSizeRestrictions, getAreaSizeRestrictions, getPositionRestrictions, getAreaPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "../state/copyState.js";
+import { approximateSize } from "../service/approximateSize.js";
+function rotateImageAlgorithm(state, settings, rotate) {
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    var angle = isNumber(rotate) ? rotate : rotate.angle;
+    var imageCenter = rotatePoint(getCenter(__assign({ left: 0, top: 0 }, getTransformedImageSize(state))), angle);
+    result.transforms.rotate += angle;
+    result.coordinates = __assign(__assign({}, approximateSize({
+      sizeRestrictions: getSizeRestrictions(result, settings),
+      aspectRatio: getAspectRatio(result, settings),
+      width: result.coordinates.width,
+      height: result.coordinates.height
+    })), rotatePoint(getCenter(result.coordinates), angle));
+    var center = !isNumber(rotate) && rotate.center ? rotate.center : getCenter(state.coordinates);
+    var shift = diff(getCenter(state.coordinates), rotatePoint(getCenter(state.coordinates), angle, center));
+    var imageSize = getTransformedImageSize(result);
+    result.coordinates.left -= imageCenter.left - imageSize.width / 2 + result.coordinates.width / 2 - shift.left;
+    result.coordinates.top -= imageCenter.top - imageSize.height / 2 + result.coordinates.height / 2 - shift.top;
+    result.visibleArea = resizeToSizeRestrictions(result.visibleArea, mergeSizeRestrictions(getAreaSizeRestrictions(result, settings), {
+      minWidth: result.coordinates.width,
+      minHeight: result.coordinates.height
+    }));
+    result.coordinates = moveToPositionRestrictions(result.coordinates, getPositionRestrictions(result, settings));
+    result.visibleArea = applyMove(result.visibleArea, diff(getCenter(result.coordinates), getCenter(state.coordinates)));
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+    return result;
+  }
+  return state;
+}
+export {
+  rotateImageAlgorithm
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/algorithms/transformImageAlgorithm.js

@@ -0,0 +1,84 @@
+import { isNumber, isRoughlyEqual } from "../utils/index.js";
+import { applyMove, minScale, maxScale, positionToSizeRestrictions, applyScale, moveToPositionRestrictions, mergePositionRestrictions, coordinatesToPositionRestrictions, getCenter, inverseMove, fitToPositionRestrictions } from "../service/utils.js";
+import { isInitializedState, getSizeRestrictions, getPositionRestrictions, getAreaSizeRestrictions, getAreaPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "../state/copyState.js";
+function transformImageAlgorithm(state, settings, transform) {
+  var _a;
+  var _b = transform.scale, scale = _b === void 0 ? 1 : _b, _c = transform.move, move = _c === void 0 ? {} : _c;
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    var scaleFactor = 1 / (isNumber(scale) ? scale : scale.factor);
+    var scaleCenter = !isNumber(scale) ? scale.center : void 0;
+    var isAllowedScale = !isRoughlyEqual(scaleFactor, 1);
+    var areaScale = 1;
+    var stencilScale = 1;
+    result.visibleArea = applyMove(result.visibleArea, {
+      left: move.left || 0,
+      top: move.top || 0
+    });
+    var sizeRestrictions = getSizeRestrictions(result, settings);
+    var positionRestrictions = getPositionRestrictions(result, settings);
+    var areaSizeRestrictions = getAreaSizeRestrictions(result, settings);
+    var scaleRestrictions = {
+      stencil: {
+        minimum: Math.max(sizeRestrictions.minWidth ? sizeRestrictions.minWidth / result.coordinates.width : 0, sizeRestrictions.minHeight ? sizeRestrictions.minHeight / result.coordinates.height : 0),
+        maximum: Math.min(sizeRestrictions.maxWidth ? sizeRestrictions.maxWidth / result.coordinates.width : Infinity, sizeRestrictions.maxHeight ? sizeRestrictions.maxHeight / result.coordinates.height : Infinity, maxScale(result.coordinates, positionToSizeRestrictions(positionRestrictions)))
+      },
+      area: {
+        maximum: maxScale(result.visibleArea, areaSizeRestrictions),
+        minimum: minScale(result.visibleArea, areaSizeRestrictions)
+      }
+    };
+    if (scaleFactor && isAllowedScale) {
+      if (scaleFactor < 1) {
+        stencilScale = Math.max(scaleFactor, Math.max(scaleRestrictions.area.minimum, scaleRestrictions.stencil.minimum));
+        if (stencilScale > 1) {
+          stencilScale = 1;
+        }
+      } else if (scaleFactor > 1) {
+        stencilScale = Math.min(scaleFactor, Math.min(scaleRestrictions.area.maximum, scaleRestrictions.stencil.maximum));
+        if (stencilScale < 1) {
+          stencilScale = 1;
+        }
+      }
+    }
+    if (stencilScale) {
+      result.visibleArea = applyScale(result.visibleArea, stencilScale, scaleCenter);
+    }
+    var relativeCoordinates = {
+      left: state.coordinates.left - state.visibleArea.left,
+      right: state.visibleArea.width + state.visibleArea.left - (state.coordinates.width + state.coordinates.left),
+      top: state.coordinates.top - state.visibleArea.top,
+      bottom: state.visibleArea.height + state.visibleArea.top - (state.coordinates.height + state.coordinates.top)
+    };
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, {
+      left: positionRestrictions.left !== void 0 ? positionRestrictions.left - relativeCoordinates.left * stencilScale : void 0,
+      top: positionRestrictions.top !== void 0 ? positionRestrictions.top - relativeCoordinates.top * stencilScale : void 0,
+      bottom: positionRestrictions.bottom !== void 0 ? positionRestrictions.bottom + relativeCoordinates.bottom * stencilScale : void 0,
+      right: positionRestrictions.right !== void 0 ? positionRestrictions.right + relativeCoordinates.right * stencilScale : void 0
+    });
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+    result.coordinates.width = result.coordinates.width * stencilScale;
+    result.coordinates.height = result.coordinates.height * stencilScale;
+    result.coordinates.left = result.visibleArea.left + relativeCoordinates.left * stencilScale;
+    result.coordinates.top = result.visibleArea.top + relativeCoordinates.top * stencilScale;
+    result.coordinates = moveToPositionRestrictions(result.coordinates, mergePositionRestrictions(coordinatesToPositionRestrictions(result.visibleArea), positionRestrictions));
+    if (isAllowedScale && scaleFactor && ((_a = settings.transformImage) === null || _a === void 0 ? void 0 : _a.adjustStencil)) {
+      if (scaleFactor > 1) {
+        areaScale = Math.min(scaleRestrictions.area.maximum, scaleFactor) / stencilScale;
+      } else if (scaleFactor < 1) {
+        areaScale = Math.max(result.coordinates.height / result.visibleArea.height, result.coordinates.width / result.visibleArea.width, scaleFactor / stencilScale);
+      }
+      if (areaScale !== 1) {
+        result.visibleArea = applyScale(result.visibleArea, areaScale, scaleFactor > 1 ? scaleCenter : getCenter(result.coordinates));
+        result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+        result.visibleArea = applyMove(result.visibleArea, inverseMove(fitToPositionRestrictions(result.coordinates, coordinatesToPositionRestrictions(result.visibleArea))));
+      }
+    }
+    return result;
+  }
+  return state;
+}
+export {
+  transformImageAlgorithm
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/animation/index.js

@@ -0,0 +1,78 @@
+var timingFunctions = {
+  linear: function(t) {
+    return t;
+  },
+  "ease-in": function(t) {
+    return Math.pow(t, 1.675);
+  },
+  "ease-out": function(t) {
+    return 1 - Math.pow(1 - t, 1.675);
+  },
+  "ease-in-out": function(t) {
+    return 0.5 * (Math.sin((t - 0.5) * Math.PI) + 1);
+  }
+};
+var Animation = (
+  /** @class */
+  function() {
+    function Animation2() {
+      this.active = false;
+    }
+    Animation2.prototype.start = function(animation) {
+      var _a;
+      this.onStart = animation.onStart;
+      this.onProgress = animation.onProgress;
+      this.onStop = animation.onStop;
+      if (!this.active) {
+        (_a = this.onStart) === null || _a === void 0 ? void 0 : _a.call(this);
+      }
+      if (this.id) {
+        window.cancelAnimationFrame(this.id);
+      }
+      this.startTime = performance.now();
+      this.timingFunction = animation.timingFunction;
+      this.endTime = this.startTime + animation.duration;
+      this.active = true;
+      this.animate();
+    };
+    Animation2.prototype.animate = function() {
+      var _this = this;
+      if (this.startTime && this.endTime) {
+        var timingFunction = timingFunctions[this.timingFunction];
+        if (!timingFunction) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn("[Animation] The timing function '" + timingFunction + "' is not supported. Available timing function: 'linear', 'ease-in', 'ease-in-out', 'ease-out'. Reset to 'ease-out'.");
+          }
+          timingFunction = timingFunctions["ease-out"];
+        }
+        var percent = 1 - (this.endTime - performance.now()) / (this.endTime - this.startTime);
+        var progress = Math.min(1, timingFunction(percent));
+        if (this.onProgress) {
+          this.onProgress(progress);
+        }
+        if (percent < 1) {
+          this.id = window.requestAnimationFrame(function() {
+            return _this.animate();
+          });
+        } else {
+          this.stop();
+        }
+      } else {
+        this.stop();
+      }
+    };
+    Animation2.prototype.stop = function() {
+      this.active = false;
+      if (this.id) {
+        window.cancelAnimationFrame(this.id);
+      }
+      if (this.onStop) {
+        this.onStop();
+      }
+    };
+    return Animation2;
+  }()
+);
+export {
+  Animation
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/boundary/index.js

@@ -0,0 +1,31 @@
+function stretchCropperBoundary(boundary, stretcher, size) {
+  stretcher.style.width = "0px";
+  stretcher.style.height = "0px";
+  stretcher.style.width = Math.max(boundary.clientWidth, size.width) + "px";
+  var ratio = size.width / size.height;
+  stretcher.style.height = Math.max(boundary.clientHeight, stretcher.clientWidth / ratio) + "px";
+  stretcher.style.width = stretcher.clientHeight * ratio + "px";
+}
+function stretchPreviewBoundary(boundary, stretcher, size) {
+  stretcher.style.width = "0px";
+  stretcher.style.height = "0px";
+  stretcher.style.width = Math.max(boundary.getBoundingClientRect().width, size.width) + "px";
+  var ratio = size.width / size.height;
+  stretcher.style.height = Math.max(boundary.getBoundingClientRect().height, stretcher.getBoundingClientRect().width / ratio) + "px";
+  stretcher.style.width = stretcher.getBoundingClientRect().height * ratio + "px";
+  if (stretcher.clientWidth / stretcher.clientHeight > boundary.clientWidth / boundary.clientHeight) {
+    if (stretcher.clientWidth > boundary.clientWidth) {
+      stretcher.style.width = boundary.clientWidth + "px";
+      stretcher.style.height = boundary.clientWidth / ratio + "px";
+    }
+  } else {
+    if (stretcher.clientHeight > boundary.clientHeight) {
+      stretcher.style.height = boundary.clientHeight + "px";
+      stretcher.style.width = boundary.clientHeight * ratio + "px";
+    }
+  }
+}
+export {
+  stretchCropperBoundary,
+  stretchPreviewBoundary
+};