dune-react 0.0.42 → 0.0.44

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
+};

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

@@ -0,0 +1,94 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { isNumeric } from "../utils/index.js";
+import { rotatePoint, getCenter, rotateSize } from "../service/utils.js";
+import { isInitializedState } from "../service/helpers.js";
+import { approximateSize } from "../service/approximateSize.js";
+function prepareSource(canvas, image, _a) {
+  var rotate = _a.rotate, flip = _a.flip;
+  var originalSize = {
+    width: "naturalWidth" in image ? image.naturalWidth : image.width,
+    height: "naturalHeight" in image ? image.naturalHeight : image.height
+  };
+  var transformedSize = rotateSize(originalSize, rotate);
+  var ctx = canvas.getContext("2d");
+  canvas.height = transformedSize.height;
+  canvas.width = transformedSize.width;
+  if (ctx) {
+    ctx.save();
+    var canvasCenter = rotatePoint(getCenter(__assign({ left: 0, top: 0 }, originalSize)), rotate);
+    ctx.translate(-(canvasCenter.left - transformedSize.width / 2), -(canvasCenter.top - transformedSize.height / 2));
+    ctx.rotate(rotate * Math.PI / 180);
+    ctx.translate(flip.horizontal ? originalSize.width : 0, flip.vertical ? originalSize.height : 0);
+    ctx.scale(flip.horizontal ? -1 : 1, flip.vertical ? -1 : 1);
+    ctx.drawImage(image, 0, 0, originalSize.width, originalSize.height);
+    ctx.restore();
+  }
+  return canvas;
+}
+function updateCanvas(canvas, source, coordinates, resultSize, options) {
+  canvas.width = resultSize ? resultSize.width : coordinates.width;
+  canvas.height = resultSize ? resultSize.height : coordinates.height;
+  var ctx = canvas.getContext("2d");
+  if (ctx) {
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (options) {
+      if (options.imageSmoothingEnabled) {
+        ctx.imageSmoothingEnabled = options.imageSmoothingEnabled;
+      }
+      if (options.imageSmoothingQuality) {
+        ctx.imageSmoothingQuality = options.imageSmoothingQuality;
+      }
+      if (options.fillColor) {
+        ctx.fillStyle = options.fillColor;
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        ctx.save();
+      }
+    }
+    var offsetX = coordinates.left < 0 ? -coordinates.left : 0;
+    var offsetY = coordinates.top < 0 ? -coordinates.top : 0;
+    ctx.drawImage(source, coordinates.left + offsetX, coordinates.top + offsetY, coordinates.width, coordinates.height, offsetX * (canvas.width / coordinates.width), offsetY * (canvas.height / coordinates.height), canvas.width, canvas.height);
+  }
+  return canvas;
+}
+function drawCroppedArea(state, image, resultCanvas, spareCanvas, options) {
+  if (isInitializedState(state)) {
+    var transforms = state.transforms, coordinates = state.coordinates;
+    var imageTransformed = transforms.rotate !== 0 || transforms.flip.horizontal || transforms.flip.vertical;
+    var source = imageTransformed ? prepareSource(spareCanvas, image, transforms) : image;
+    var params = __assign({ minWidth: 0, minHeight: 0, maxWidth: Infinity, maxHeight: Infinity, maxArea: Infinity, imageSmoothingEnabled: true, imageSmoothingQuality: "high", fillColor: "transparent" }, options);
+    var firstNumeric = function(array) {
+      return array.find(function(el) {
+        return isNumeric(el);
+      });
+    };
+    var size = approximateSize({
+      sizeRestrictions: {
+        minWidth: firstNumeric([params.width, params.minWidth]) || 0,
+        minHeight: firstNumeric([params.height, params.minHeight]) || 0,
+        maxWidth: firstNumeric([params.width, params.maxWidth]) || Infinity,
+        maxHeight: firstNumeric([params.height, params.maxHeight]) || Infinity
+      },
+      width: coordinates.width,
+      height: coordinates.height,
+      aspectRatio: {
+        minimum: coordinates.width / coordinates.height,
+        maximum: coordinates.width / coordinates.height
+      }
+    });
+    if (params.maxArea && size.width * size.height > params.maxArea) {
+      var scale = Math.sqrt(params.maxArea / (size.width * size.height));
+      size = {
+        width: Math.round(scale * size.width),
+        height: Math.round(scale * size.height)
+      };
+    }
+    return updateCanvas(resultCanvas, source, coordinates, size, params);
+  } else {
+    return null;
+  }
+}
+export {
+  drawCroppedArea,
+  prepareSource,
+  updateCanvas
+};

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

@@ -0,0 +1,8 @@
+var ALL_DIRECTIONS = ["left", "right", "top", "bottom"];
+var HORIZONTAL_DIRECTIONS = ["left", "right"];
+var VERTICAL_DIRECTIONS = ["top", "bottom"];
+export {
+  ALL_DIRECTIONS,
+  HORIZONTAL_DIRECTIONS,
+  VERTICAL_DIRECTIONS
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/defaults/defaultAreaPositionRestrictions.js

@@ -0,0 +1,51 @@
+import { ratio } from "../service/utils.js";
+import { getTransformedImageSize } from "../service/helpers.js";
+import { ImageRestriction } from "../types/index.js";
+function defaultAreaPositionRestrictions(state, settings) {
+  var visibleArea = state.visibleArea, boundary = state.boundary;
+  var imageRestriction = settings.imageRestriction;
+  var imageSize = getTransformedImageSize(state);
+  var restrictions = {};
+  if (imageRestriction === ImageRestriction.fillArea) {
+    restrictions = {
+      left: 0,
+      top: 0,
+      right: imageSize.width,
+      bottom: imageSize.height
+    };
+  } else if (imageRestriction === ImageRestriction.fitArea) {
+    if (ratio(boundary) > ratio(imageSize)) {
+      restrictions = {
+        top: 0,
+        bottom: imageSize.height
+      };
+      if (visibleArea) {
+        if (visibleArea.width > imageSize.width) {
+          restrictions.left = -(visibleArea.width - imageSize.width) / 2;
+          restrictions.right = imageSize.width - restrictions.left;
+        } else {
+          restrictions.left = 0;
+          restrictions.right = imageSize.width;
+        }
+      }
+    } else {
+      restrictions = {
+        left: 0,
+        right: imageSize.width
+      };
+      if (visibleArea) {
+        if (visibleArea.height > imageSize.height) {
+          restrictions.top = -(visibleArea.height - imageSize.height) / 2;
+          restrictions.bottom = imageSize.height - restrictions.top;
+        } else {
+          restrictions.top = 0;
+          restrictions.bottom = imageSize.height;
+        }
+      }
+    }
+  }
+  return restrictions;
+}
+export {
+  defaultAreaPositionRestrictions
+};