dune-react 0.0.43 → 0.0.44

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/helpers.js

@@ -0,0 +1,125 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { emptyCoordinates, isFunction, isNumber, isBoolean } from "../utils/index.js";
+import { createAspectRatio, getBrokenRatio, ratio, isConsistentSize, isConsistentPosition, moveToPositionRestrictions, rotateSize } from "./utils.js";
+import { calculateAreaSizeRestrictions, calculateSizeRestrictions } from "./sizeRestrictions.js";
+function isInitializedState(state) {
+  return Boolean(state && state.visibleArea && state.coordinates);
+}
+function getAreaSizeRestrictions(state, settings) {
+  return calculateAreaSizeRestrictions(state, settings);
+}
+function getAreaPositionRestrictions(state, settings) {
+  return isFunction(settings.areaPositionRestrictions) ? settings.areaPositionRestrictions(state, settings) : settings.areaPositionRestrictions;
+}
+function getSizeRestrictions(state, settings) {
+  return calculateSizeRestrictions(state, settings);
+}
+function getPositionRestrictions(state, settings) {
+  return isFunction(settings.positionRestrictions) ? settings.positionRestrictions(state, settings) : settings.positionRestrictions;
+}
+function getCoefficient(state) {
+  return state.visibleArea ? state.visibleArea.width / state.boundary.width : 0;
+}
+function getStencilCoordinates(state) {
+  if (isInitializedState(state)) {
+    var _a = state.coordinates, width = _a.width, height = _a.height, left = _a.left, top_1 = _a.top;
+    var coefficient = getCoefficient(state);
+    return {
+      width: width / coefficient,
+      height: height / coefficient,
+      left: (left - state.visibleArea.left) / coefficient,
+      top: (top_1 - state.visibleArea.top) / coefficient
+    };
+  } else {
+    return emptyCoordinates();
+  }
+}
+function getAspectRatio(state, settings) {
+  return createAspectRatio(isFunction(settings.aspectRatio) ? settings.aspectRatio(state, settings) : settings.aspectRatio);
+}
+function getDefaultCoordinates(state, settings) {
+  return isFunction(settings.defaultCoordinates) ? settings.defaultCoordinates(state, settings) : settings.defaultCoordinates;
+}
+function getDefaultVisibleArea(state, settings) {
+  return isFunction(settings.defaultVisibleArea) ? settings.defaultVisibleArea(state, settings) : settings.defaultVisibleArea;
+}
+function getDefaultTransforms(state, settings) {
+  var transforms = __assign(__assign({}, state.transforms), { flip: __assign({}, state.transforms.flip) });
+  if (settings.defaultTransforms) {
+    var defaultTransforms = isFunction(settings.defaultTransforms) ? settings.defaultTransforms(state, settings) : settings.defaultTransforms;
+    if (isNumber(defaultTransforms.rotate)) {
+      transforms.rotate = defaultTransforms.rotate;
+    }
+    if (defaultTransforms.flip) {
+      if (isBoolean(defaultTransforms.flip.horizontal)) {
+        transforms.flip.horizontal = defaultTransforms.flip.horizontal;
+      }
+      if (isBoolean(defaultTransforms.flip.vertical)) {
+        transforms.flip.vertical = defaultTransforms.flip.vertical;
+      }
+    }
+  }
+  return transforms;
+}
+function getTransformedImageSize(state) {
+  if (state.imageSize && state.imageSize.width && state.imageSize.height) {
+    return rotateSize(state.imageSize, state.transforms.rotate);
+  } else {
+    return {
+      width: 0,
+      height: 0
+    };
+  }
+}
+function getMinimumSize(state) {
+  return state.coordinates ? Math.min(state.coordinates.width, state.coordinates.height, 20 * getCoefficient(state)) : 1;
+}
+function getRoundedCoordinates(state, settings) {
+  if (isInitializedState(state)) {
+    var sizeRestrictions = getSizeRestrictions(state, settings);
+    var positionRestrictions = getPositionRestrictions(state, settings);
+    var roundCoordinates = {
+      width: Math.round(state.coordinates.width),
+      height: Math.round(state.coordinates.height),
+      left: Math.round(state.coordinates.left),
+      top: Math.round(state.coordinates.top)
+    };
+    if (roundCoordinates.width > sizeRestrictions.maxWidth) {
+      roundCoordinates.width = Math.floor(state.coordinates.width);
+    } else if (roundCoordinates.width < sizeRestrictions.minWidth) {
+      roundCoordinates.width = Math.ceil(state.coordinates.width);
+    }
+    if (roundCoordinates.height > sizeRestrictions.maxHeight) {
+      roundCoordinates.height = Math.floor(state.coordinates.height);
+    } else if (roundCoordinates.height < sizeRestrictions.minHeight) {
+      roundCoordinates.height = Math.ceil(state.coordinates.height);
+    }
+    return moveToPositionRestrictions(roundCoordinates, positionRestrictions);
+  } else {
+    return null;
+  }
+}
+function isConsistentState(state, settings) {
+  if (isInitializedState(state)) {
+    return !getBrokenRatio(ratio(state.coordinates), getAspectRatio(state, settings)) && isConsistentSize(state.visibleArea, getAreaSizeRestrictions(state, settings)) && isConsistentSize(state.coordinates, getSizeRestrictions(state, settings)) && isConsistentPosition(state.visibleArea, getAreaPositionRestrictions(state, settings)) && isConsistentPosition(state.coordinates, getPositionRestrictions(state, settings));
+  } else {
+    return true;
+  }
+}
+export {
+  getAreaPositionRestrictions,
+  getAreaSizeRestrictions,
+  getAspectRatio,
+  getCoefficient,
+  getDefaultCoordinates,
+  getDefaultTransforms,
+  getDefaultVisibleArea,
+  getMinimumSize,
+  getPositionRestrictions,
+  getRoundedCoordinates,
+  getSizeRestrictions,
+  getStencilCoordinates,
+  getTransformedImageSize,
+  isConsistentState,
+  isInitializedState
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/imageTransforms.js

@@ -0,0 +1,83 @@
+import { isRoughlyEqual, sign, distance } from "../utils/index.js";
+function calculateGeometricProperties(touches, container) {
+  var _a = container.getBoundingClientRect(), left = _a.left, top = _a.top;
+  var centerMass = { left: 0, top: 0 };
+  var spread = 0;
+  touches.forEach(function(touch) {
+    centerMass.left += (touch.clientX - left) / touches.length;
+    centerMass.top += (touch.clientY - top) / touches.length;
+  });
+  touches.forEach(function(touch) {
+    spread += distance({ left: centerMass.left, top: centerMass.top }, { left: touch.clientX - left, top: touch.clientY - top });
+  });
+  return { centerMass, spread, count: touches.length };
+}
+function touchesToImageTransform(touches, previousTouches, container, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var move, scale, rotate;
+  if (previousTouches.length === 1 && touches.length === 1) {
+    if (options.move) {
+      move = {
+        left: previousTouches[0].clientX - touches[0].clientX,
+        top: previousTouches[0].clientY - touches[0].clientY
+      };
+    }
+  } else if (touches.length > 1) {
+    var previousProperties = calculateGeometricProperties(previousTouches, container);
+    var properties = calculateGeometricProperties(touches, container);
+    if (options.rotate && previousTouches.length === 2 && touches.length === 2) {
+      var diffs = {
+        left: [
+          touches[0].clientX - touches[1].clientX,
+          previousTouches[0].clientX - previousTouches[1].clientX
+        ],
+        top: [touches[0].clientY - touches[1].clientY, previousTouches[0].clientY - previousTouches[1].clientY]
+      };
+      var y = diffs.left[0] * diffs.top[1] - diffs.left[1] * diffs.top[0];
+      var x = diffs.left[0] * diffs.left[1] + diffs.top[0] * diffs.top[1];
+      if (!isRoughlyEqual(x, 0) && !isRoughlyEqual(y, 0)) {
+        var radians = Math.atan2(y, x);
+        var angle = -(radians * 180) / Math.PI;
+        rotate = {
+          center: properties.centerMass,
+          angle
+        };
+      }
+    }
+    if (options.move) {
+      move = {
+        left: previousProperties.centerMass.left - properties.centerMass.left,
+        top: previousProperties.centerMass.top - properties.centerMass.top
+      };
+    }
+    if (options.scale) {
+      scale = {
+        factor: properties.spread / previousProperties.spread,
+        center: properties.centerMass
+      };
+    }
+  }
+  return {
+    move,
+    scale,
+    rotate
+  };
+}
+function wheelEventToImageTransform(event, container, ratio) {
+  if (ratio === void 0) {
+    ratio = 0.1;
+  }
+  var _a = container.getBoundingClientRect(), left = _a.left, top = _a.top;
+  var factor = 1 - ratio * sign(event.deltaY || event.detail || event.wheelDelta);
+  var center = {
+    left: event.clientX - left,
+    top: event.clientY - top
+  };
+  return { scale: { factor, center } };
+}
+export {
+  touchesToImageTransform,
+  wheelEventToImageTransform
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/interactions.js

@@ -0,0 +1,19 @@
+function hasInteractions(interactions) {
+  return interactions.moveCoordinates || interactions.resizeCoordinates || interactions.transformImage.move || interactions.transformImage.rotate || interactions.transformImage.flip || interactions.transformImage.scale;
+}
+function getEmptyInteractions() {
+  return {
+    moveCoordinates: false,
+    resizeCoordinates: false,
+    transformImage: {
+      rotate: false,
+      move: false,
+      scale: false,
+      flip: false
+    }
+  };
+}
+export {
+  getEmptyInteractions,
+  hasInteractions
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/normalize.js

@@ -0,0 +1,83 @@
+import { isNumber } from "../utils/index.js";
+import { getCoefficient } from "./helpers.js";
+function normalizeResizeDirections(state, directions) {
+  var coefficient = getCoefficient(state);
+  return {
+    left: isNumber(directions.left) ? directions.left * coefficient : 0,
+    top: isNumber(directions.top) ? directions.top * coefficient : 0,
+    right: isNumber(directions.right) ? directions.right * coefficient : 0,
+    bottom: isNumber(directions.bottom) ? directions.bottom * coefficient : 0
+  };
+}
+function normalizeCenter(state, center) {
+  var coefficient = getCoefficient(state);
+  if (state.visibleArea) {
+    return {
+      left: center.left * coefficient + state.visibleArea.left,
+      top: center.top * coefficient + state.visibleArea.top
+    };
+  }
+  return center;
+}
+function normalizeFlip(state, flip) {
+  if (state) {
+    var normalizedAngle = Math.abs(state.transforms.rotate % 180);
+    if (normalizedAngle <= 45 || normalizedAngle >= 135) {
+      return flip;
+    } else {
+      return {
+        horizontal: flip.vertical,
+        vertical: flip.horizontal
+      };
+    }
+  }
+  return flip;
+}
+function fillMoveDirections(directions) {
+  return {
+    left: isNumber(directions.left) ? directions.left : 0,
+    top: isNumber(directions.top) ? directions.top : 0
+  };
+}
+function fillResizeDirections(directions) {
+  return {
+    left: isNumber(directions.left) ? directions.left : 0,
+    top: isNumber(directions.top) ? directions.top : 0,
+    right: isNumber(directions.right) ? directions.right : 0,
+    bottom: isNumber(directions.bottom) ? directions.bottom : 0
+  };
+}
+function normalizeMoveDirections(state, directions) {
+  var coefficient = getCoefficient(state);
+  return {
+    left: isNumber(directions.left) ? directions.left * coefficient : 0,
+    top: isNumber(directions.top) ? directions.top * coefficient : 0
+  };
+}
+function normalizeImageTransform(state, transform) {
+  if (transform.scale) {
+    transform.scale = {
+      factor: isNumber(transform.scale) ? transform.scale : transform.scale.factor,
+      center: !isNumber(transform.scale) && transform.scale.center ? normalizeCenter(state, transform.scale.center) : void 0
+    };
+  }
+  if (transform.rotate) {
+    transform.rotate = {
+      angle: isNumber(transform.rotate) ? transform.rotate : transform.rotate.angle,
+      center: !isNumber(transform.rotate) && transform.rotate.center ? normalizeCenter(state, transform.rotate.center) : void 0
+    };
+  }
+  if (transform.move) {
+    transform.move = normalizeMoveDirections(state, transform.move);
+  }
+  return transform;
+}
+export {
+  fillMoveDirections,
+  fillResizeDirections,
+  normalizeCenter,
+  normalizeFlip,
+  normalizeImageTransform,
+  normalizeMoveDirections,
+  normalizeResizeDirections
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/sizeRestrictions.js

@@ -0,0 +1,58 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { isFunction, isNumeric, parseNumber } from "../utils/index.js";
+import { ratio } from "./utils.js";
+import { getPositionRestrictions } from "./helpers.js";
+function reconcileSizeRestrictions(sizeRestrictions) {
+  var restrictions = __assign({}, sizeRestrictions);
+  if (restrictions.minWidth > restrictions.maxWidth) {
+    restrictions.minWidth = restrictions.maxWidth;
+  }
+  if (restrictions.minHeight > restrictions.maxHeight) {
+    restrictions.minHeight = restrictions.maxHeight;
+  }
+  return restrictions;
+}
+function mergeSizeRestrictions(a, b) {
+  var first = a;
+  var second = __assign({ minWidth: 0, minHeight: 0, maxWidth: Infinity, maxHeight: Infinity }, b);
+  return reconcileSizeRestrictions({
+    maxHeight: Math.min(first.maxHeight, second.maxHeight),
+    minHeight: Math.max(first.minHeight, second.minHeight),
+    maxWidth: Math.min(first.maxWidth, second.maxWidth),
+    minWidth: Math.max(first.minWidth, second.minWidth)
+  });
+}
+function calculateSizeRestrictions(state, settings) {
+  var sizeRestrictions = isFunction(settings.sizeRestrictions) ? settings.sizeRestrictions(state, settings) : settings.sizeRestrictions;
+  var positionRestrictions = getPositionRestrictions(state, settings);
+  var restrictions = {
+    minWidth: isNumeric(sizeRestrictions.minWidth) ? parseNumber(sizeRestrictions.minWidth) : 0,
+    minHeight: isNumeric(sizeRestrictions.minHeight) ? parseNumber(sizeRestrictions.minHeight) : 0,
+    maxWidth: isNumeric(sizeRestrictions.maxWidth) ? parseNumber(sizeRestrictions.maxWidth) : Infinity,
+    maxHeight: isNumeric(sizeRestrictions.maxHeight) ? parseNumber(sizeRestrictions.maxHeight) : Infinity
+  };
+  if (positionRestrictions.left !== void 0 && positionRestrictions.right !== void 0) {
+    restrictions.maxWidth = Math.min(restrictions.maxWidth, positionRestrictions.right - positionRestrictions.left);
+  }
+  if (positionRestrictions.bottom !== void 0 && positionRestrictions.top !== void 0) {
+    restrictions.maxHeight = Math.min(restrictions.maxHeight, positionRestrictions.bottom - positionRestrictions.top);
+  }
+  return reconcileSizeRestrictions(restrictions);
+}
+function calculateAreaSizeRestrictions(state, settings) {
+  var sizeRestrictions = isFunction(settings.areaSizeRestrictions) ? settings.areaSizeRestrictions(state, settings) : settings.areaSizeRestrictions;
+  if (sizeRestrictions.maxWidth < Infinity && sizeRestrictions.maxHeight < Infinity) {
+    if (ratio(state.boundary) > sizeRestrictions.maxWidth / sizeRestrictions.maxHeight) {
+      sizeRestrictions.maxHeight = sizeRestrictions.maxWidth / ratio(state.boundary);
+    } else {
+      sizeRestrictions.maxWidth = sizeRestrictions.maxHeight * ratio(state.boundary);
+    }
+  }
+  return reconcileSizeRestrictions(sizeRestrictions);
+}
+export {
+  calculateAreaSizeRestrictions,
+  calculateSizeRestrictions,
+  mergeSizeRestrictions,
+  reconcileSizeRestrictions
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/service/utils.js

@@ -0,0 +1,313 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { ALL_DIRECTIONS } from "../constants/index.js";
+import { isNumber, isNumeric, isFunction, isLower, isUndefined, isGreater } from "../utils/index.js";
+function diff(firstObject, secondObject) {
+  return {
+    left: firstObject.left - secondObject.left,
+    top: firstObject.top - secondObject.top
+  };
+}
+function getCenter(object) {
+  return {
+    left: object.left + object.width / 2,
+    top: object.top + object.height / 2
+  };
+}
+function getOppositeSide(side) {
+  return {
+    left: "right",
+    top: "bottom",
+    right: "left",
+    bottom: "top"
+  }[side];
+}
+function sizeDistance(a, b) {
+  return Math.pow(a.width - b.width, 2) + Math.pow(a.height - b.height, 2);
+}
+function applyDirections(coordinates, directions) {
+  return {
+    left: coordinates.left - directions.left,
+    top: coordinates.top - directions.top,
+    width: coordinates.width + directions.left + directions.right,
+    height: coordinates.height + directions.top + directions.bottom
+  };
+}
+function inverseMove(directions) {
+  return {
+    left: -directions.left,
+    top: -directions.top
+  };
+}
+function applyMove(object, move) {
+  return __assign(__assign({}, object), { left: object.left + move.left, top: object.top + move.top });
+}
+function coordinatesToPositionRestrictions(coordinates) {
+  return {
+    left: coordinates.left,
+    top: coordinates.top,
+    right: coordinates.left + coordinates.width,
+    bottom: coordinates.top + coordinates.height
+  };
+}
+function applyScale(object, factor, center, progress) {
+  if (factor !== 1) {
+    if ("left" in object || "top" in object) {
+      if (center) {
+        var currentCenter = getCenter(object);
+        return {
+          width: object.width * factor,
+          height: object.height * factor,
+          left: object.left + object.width * (1 - factor) / 2 + (center.left - currentCenter.left) * (1 - factor),
+          top: object.top + object.height * (1 - factor) / 2 + (center.top - currentCenter.top) * (1 - factor)
+        };
+      } else {
+        return {
+          width: object.width * factor,
+          height: object.height * factor,
+          left: object.left + object.width * (1 - factor) / 2,
+          top: object.top + object.height * (1 - factor) / 2
+        };
+      }
+    } else {
+      return {
+        width: object.width * factor,
+        height: object.height * factor
+      };
+    }
+  } else {
+    return object;
+  }
+}
+function ratio(object) {
+  return object.width / object.height;
+}
+function maxScale(size, restrictions) {
+  return Math.min(restrictions.maxWidth ? restrictions.maxWidth / size.width : Infinity, restrictions.maxHeight ? restrictions.maxHeight / size.height : Infinity);
+}
+function minScale(size, restrictions) {
+  return Math.max(restrictions.minWidth ? restrictions.minWidth / size.width : 0, restrictions.minHeight ? restrictions.minHeight / size.height : 0);
+}
+function getBrokenRatio(currentAspectRatio, aspectRatio) {
+  var ratioBroken;
+  if (aspectRatio.minimum && isLower(currentAspectRatio, aspectRatio.minimum)) {
+    ratioBroken = aspectRatio.minimum;
+  } else if (aspectRatio.maximum && isGreater(currentAspectRatio, aspectRatio.maximum)) {
+    ratioBroken = aspectRatio.maximum;
+  }
+  return ratioBroken;
+}
+function fitToSizeRestrictions(coordinates, sizeRestrictions) {
+  var aspectRatio = ratio(coordinates);
+  var scale = 1;
+  if (sizeRestrictions.minWidth > 0 && sizeRestrictions.minHeight > 0) {
+    if (aspectRatio > sizeRestrictions.minWidth / sizeRestrictions.minHeight) {
+      if (coordinates.height < sizeRestrictions.minHeight) {
+        scale = sizeRestrictions.minHeight / coordinates.height;
+      }
+    } else {
+      if (coordinates.width < sizeRestrictions.minWidth) {
+        scale = sizeRestrictions.minWidth / coordinates.width;
+      }
+    }
+  } else if (sizeRestrictions.minWidth > 0) {
+    if (coordinates.width < sizeRestrictions.minWidth) {
+      scale = sizeRestrictions.minWidth / coordinates.width;
+    }
+  } else if (sizeRestrictions.minHeight > 0) {
+    if (coordinates.height < sizeRestrictions.minHeight) {
+      scale = sizeRestrictions.minHeight / coordinates.height;
+    }
+  }
+  if (sizeRestrictions.maxWidth < Infinity && sizeRestrictions.maxHeight < Infinity) {
+    if (aspectRatio > sizeRestrictions.maxWidth / sizeRestrictions.maxHeight) {
+      if (coordinates.width > sizeRestrictions.maxWidth) {
+        scale = sizeRestrictions.maxWidth / coordinates.width;
+      }
+    } else {
+      if (coordinates.height > sizeRestrictions.maxHeight) {
+        scale = sizeRestrictions.maxHeight / coordinates.height;
+      }
+    }
+  } else if (sizeRestrictions.maxWidth < Infinity) {
+    if (coordinates.width > sizeRestrictions.maxWidth) {
+      scale = sizeRestrictions.maxWidth / coordinates.width;
+    }
+  } else if (sizeRestrictions.maxHeight < Infinity) {
+    if (coordinates.height > sizeRestrictions.maxHeight) {
+      scale = sizeRestrictions.maxHeight / coordinates.height;
+    }
+  }
+  return scale;
+}
+function getIntersections(object, positionRestrictions) {
+  var intersections = {
+    left: 0,
+    top: 0,
+    right: 0,
+    bottom: 0
+  };
+  ALL_DIRECTIONS.forEach(function(direction) {
+    var areaLimit = positionRestrictions[direction];
+    var objectLimit = coordinatesToPositionRestrictions(object)[direction];
+    if (areaLimit !== void 0 && objectLimit !== void 0) {
+      if (direction === "left" || direction === "top") {
+        intersections[direction] = Math.max(0, areaLimit - objectLimit);
+      } else {
+        intersections[direction] = Math.max(0, objectLimit - areaLimit);
+      }
+    } else {
+      intersections[direction] = 0;
+    }
+  });
+  return intersections;
+}
+function resizeToSizeRestrictions(coordinates, sizeRestrictions) {
+  return applyScale(coordinates, fitToSizeRestrictions(coordinates, sizeRestrictions));
+}
+function rotateSize(size, angle) {
+  var radians = angle * Math.PI / 180;
+  return {
+    width: Math.abs(size.width * Math.cos(radians)) + Math.abs(size.height * Math.sin(radians)),
+    height: Math.abs(size.width * Math.sin(radians)) + Math.abs(size.height * Math.cos(radians))
+  };
+}
+function rotatePoint(point, angle, anchor) {
+  var radians = angle * Math.PI / 180;
+  if (anchor) {
+    return {
+      left: (point.left - anchor.left) * Math.cos(radians) - (point.top - anchor.top) * Math.sin(radians) + anchor.left,
+      top: (point.left - anchor.left) * Math.sin(radians) + (point.top - anchor.top) * Math.cos(radians) + anchor.top
+    };
+  } else {
+    return {
+      left: point.left * Math.cos(radians) - point.top * Math.sin(radians),
+      top: point.left * Math.sin(radians) + point.top * Math.cos(radians)
+    };
+  }
+}
+function positionToSizeRestrictions(positionRestrictions) {
+  return {
+    minWidth: 0,
+    minHeight: 0,
+    maxWidth: positionRestrictions.right !== void 0 && positionRestrictions.left !== void 0 ? positionRestrictions.right - positionRestrictions.left : Infinity,
+    maxHeight: positionRestrictions.bottom !== void 0 && positionRestrictions.top !== void 0 ? positionRestrictions.bottom - positionRestrictions.top : Infinity
+  };
+}
+function mergePositionRestrictions(a, b) {
+  var restrictions = {};
+  ALL_DIRECTIONS.forEach(function(direction) {
+    var firstDirection = a[direction];
+    var secondDirection = b[direction];
+    if (firstDirection !== void 0 && secondDirection !== void 0) {
+      if (direction === "left" || direction === "top") {
+        restrictions[direction] = Math.max(firstDirection, secondDirection);
+      } else {
+        restrictions[direction] = Math.min(firstDirection, secondDirection);
+      }
+    } else if (secondDirection !== void 0) {
+      restrictions[direction] = secondDirection;
+    } else if (firstDirection !== void 0) {
+      restrictions[direction] = firstDirection;
+    }
+  });
+  return restrictions;
+}
+function fitToPositionRestrictions(coordinates, positionRestrictions) {
+  var directions = {
+    left: 0,
+    top: 0
+  };
+  var intersection = getIntersections(coordinates, positionRestrictions);
+  if (intersection.left && intersection.left > 0) {
+    directions.left = intersection.left;
+  } else if (intersection.right && intersection.right > 0) {
+    directions.left = -intersection.right;
+  }
+  if (intersection.top && intersection.top > 0) {
+    directions.top = intersection.top;
+  } else if (intersection.bottom && intersection.bottom > 0) {
+    directions.top = -intersection.bottom;
+  }
+  return directions;
+}
+function moveToPositionRestrictions(coordinates, positionRestrictions) {
+  return applyMove(coordinates, fitToPositionRestrictions(coordinates, positionRestrictions));
+}
+function aspectRatioIntersection(main, subset) {
+  if (!subset) {
+    return main;
+  } else if (!main) {
+    return subset;
+  } else {
+    return {
+      minimum: Math.min(main.maximum, Math.max(main.minimum, subset.minimum)),
+      maximum: Math.max(main.minimum, Math.min(main.maximum, subset.maximum))
+    };
+  }
+}
+function createAspectRatio(aspectRatio) {
+  if (aspectRatio === void 0) {
+    aspectRatio = {};
+  }
+  if (isNumber(aspectRatio)) {
+    return {
+      minimum: aspectRatio,
+      maximum: aspectRatio
+    };
+  } else {
+    return {
+      minimum: isNumeric(aspectRatio.minimum) ? aspectRatio.minimum : 0,
+      maximum: isNumeric(aspectRatio.maximum) ? aspectRatio.maximum : Infinity
+    };
+  }
+}
+function isConsistentSize(size, restrictions) {
+  return (isUndefined(restrictions.maxWidth) || !isGreater(size.width, restrictions.maxWidth)) && (isUndefined(restrictions.maxHeight) || !isGreater(size.height, restrictions.maxHeight)) && (isUndefined(restrictions.minHeight) || !isLower(size.height, restrictions.minHeight)) && (isUndefined(restrictions.minWidth) || !isLower(size.width, restrictions.minWidth));
+}
+function isConsistentPosition(coordinates, restrictions) {
+  return (isUndefined(restrictions.left) || !isLower(coordinates.left, restrictions.left)) && (isUndefined(restrictions.top) || !isLower(coordinates.top, restrictions.top)) && (isUndefined(restrictions.right) || !isGreater(coordinates.left + coordinates.width, restrictions.right)) && (isUndefined(restrictions.bottom) || !isGreater(coordinates.top + coordinates.height, restrictions.bottom));
+}
+function getCloserSize(candidates, reference, sizeRestrictions, aspectRatio) {
+  var traverse = function(ignoreMinimum) {
+    return candidates.reduce(function(minimum, size) {
+      var _a = isFunction(sizeRestrictions) ? sizeRestrictions(size) : sizeRestrictions, maxHeight = _a.maxHeight, maxWidth = _a.maxWidth, minWidth = _a.minWidth, minHeight = _a.minHeight;
+      var preparedAspectRatio = createAspectRatio(isFunction(aspectRatio) ? aspectRatio(size) : aspectRatio);
+      var preparedSizeRestrictions = ignoreMinimum ? { maxWidth, maxHeight } : { maxWidth, maxHeight, minWidth, minHeight };
+      if (isConsistentSize(size, preparedSizeRestrictions) && !getBrokenRatio(ratio(size), preparedAspectRatio) && size.width && size.height) {
+        return !minimum || isLower(sizeDistance(size, reference), sizeDistance(minimum, reference)) ? size : minimum;
+      } else {
+        return minimum;
+      }
+    }, null);
+  };
+  return traverse() || traverse(true);
+}
+export {
+  applyDirections,
+  applyMove,
+  applyScale,
+  aspectRatioIntersection,
+  coordinatesToPositionRestrictions,
+  createAspectRatio,
+  diff,
+  fitToPositionRestrictions,
+  fitToSizeRestrictions,
+  getBrokenRatio,
+  getCenter,
+  getCloserSize,
+  getIntersections,
+  getOppositeSide,
+  inverseMove,
+  isConsistentPosition,
+  isConsistentSize,
+  maxScale,
+  mergePositionRestrictions,
+  minScale,
+  moveToPositionRestrictions,
+  positionToSizeRestrictions,
+  ratio,
+  resizeToSizeRestrictions,
+  rotatePoint,
+  rotateSize,
+  sizeDistance
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/state/copyState.js

@@ -0,0 +1,7 @@
+import { deepClone } from "../utils/index.js";
+function copyState(state) {
+  return deepClone(state);
+}
+export {
+  copyState
+};