dune-react 0.0.43 → 0.0.45

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

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

@@ -0,0 +1,30 @@
+import { ratio } from "../service/utils.js";
+import { getTransformedImageSize } from "../service/helpers.js";
+import { ImageRestriction } from "../types/index.js";
+function defaultAreaSizeRestrictions(state, settings) {
+  var boundary = state.boundary;
+  var imageRestriction = settings.imageRestriction;
+  var imageSize = getTransformedImageSize(state);
+  var restrictions = {
+    minWidth: 0,
+    minHeight: 0,
+    maxWidth: Infinity,
+    maxHeight: Infinity
+  };
+  if (imageRestriction === ImageRestriction.fillArea) {
+    restrictions.maxWidth = imageSize.width;
+    restrictions.maxHeight = imageSize.height;
+  } else if (imageRestriction === ImageRestriction.fitArea) {
+    if (ratio(boundary) > ratio(imageSize)) {
+      restrictions.maxHeight = imageSize.height;
+      restrictions.maxWidth = imageSize.height * ratio(boundary);
+    } else {
+      restrictions.maxWidth = imageSize.width;
+      restrictions.maxHeight = imageSize.width / ratio(boundary);
+    }
+  }
+  return restrictions;
+}
+export {
+  defaultAreaSizeRestrictions
+};

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

@@ -0,0 +1,10 @@
+function fillBoundary(boundary) {
+  var _a = boundary.getBoundingClientRect(), width = _a.width, height = _a.height;
+  return {
+    width,
+    height
+  };
+}
+export {
+  fillBoundary
+};

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

@@ -0,0 +1,12 @@
+import { getTransformedImageSize } from "../service/helpers.js";
+function defaultPosition(state) {
+  var visibleArea = state.visibleArea, coordinates = state.coordinates;
+  var area = visibleArea || getTransformedImageSize(state);
+  return {
+    left: (visibleArea ? visibleArea.left : 0) + area.width / 2 - (coordinates ? coordinates.width / 2 : 0),
+    top: (visibleArea ? visibleArea.top : 0) + area.height / 2 - (coordinates ? coordinates.height / 2 : 0)
+  };
+}
+export {
+  defaultPosition
+};

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

@@ -0,0 +1,17 @@
+import { getTransformedImageSize } from "../service/helpers.js";
+function defaultPositionRestrictions(state, settings) {
+  var imageSize = getTransformedImageSize(state);
+  var limits = {};
+  if (settings.imageRestriction && settings.imageRestriction !== "none") {
+    limits = {
+      left: 0,
+      top: 0,
+      right: imageSize.width,
+      bottom: imageSize.height
+    };
+  }
+  return limits;
+}
+export {
+  defaultPositionRestrictions
+};

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

@@ -0,0 +1,31 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { positionToSizeRestrictions, ratio } from "../service/utils.js";
+import { getSizeRestrictions, getAspectRatio, getPositionRestrictions } from "../service/helpers.js";
+import { approximateSize } from "../service/approximateSize.js";
+function defaultSize(state, settings) {
+  var imageSize = state.imageSize, visibleArea = state.visibleArea;
+  var sizeRestrictions = getSizeRestrictions(state, settings);
+  var aspectRatio = getAspectRatio(state, settings);
+  var area;
+  if (visibleArea) {
+    area = visibleArea;
+  } else {
+    var sizeRestrictions_1 = positionToSizeRestrictions(getPositionRestrictions(state, settings));
+    area = {
+      width: Math.max(sizeRestrictions_1.minWidth, Math.min(sizeRestrictions_1.maxWidth, imageSize.width)),
+      height: Math.max(sizeRestrictions_1.minHeight, Math.min(sizeRestrictions_1.maxHeight, imageSize.height))
+    };
+  }
+  var optimalRatio = Math.min(aspectRatio.maximum || Infinity, Math.max(aspectRatio.minimum || 0, ratio(area)));
+  var size = area.width < area.height ? {
+    width: area.width * 0.8,
+    height: area.width * 0.8 / optimalRatio
+  } : {
+    height: area.height * 0.8,
+    width: area.height * 0.8 * optimalRatio
+  };
+  return approximateSize(__assign(__assign({}, size), { aspectRatio, sizeRestrictions }));
+}
+export {
+  defaultSize
+};

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

@@ -0,0 +1,16 @@
+import { isNumeric, parseNumber } from "../utils/index.js";
+function retrieveSizeRestrictions(settings) {
+  return {
+    minWidth: isNumeric(settings.minWidth) ? parseNumber(settings.minWidth) : 0,
+    minHeight: isNumeric(settings.minHeight) ? parseNumber(settings.minHeight) : 0,
+    maxWidth: isNumeric(settings.maxWidth) ? parseNumber(settings.maxWidth) : Infinity,
+    maxHeight: isNumeric(settings.maxHeight) ? parseNumber(settings.maxHeight) : Infinity
+  };
+}
+function pixelsRestrictions(state, settings) {
+  return retrieveSizeRestrictions(settings);
+}
+export {
+  pixelsRestrictions,
+  retrieveSizeRestrictions
+};

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

@@ -0,0 +1,13 @@
+import { isFunction } from "../utils/index.js";
+import { createAspectRatio } from "../service/utils.js";
+function defaultStencilConstraints(rawSettings, stencilProps) {
+  if (!rawSettings.aspectRatio) {
+    return {
+      aspectRatio: createAspectRatio(isFunction(stencilProps.aspectRatio) ? stencilProps.aspectRatio() : stencilProps.aspectRatio)
+    };
+  }
+  return {};
+}
+export {
+  defaultStencilConstraints
+};

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

@@ -0,0 +1,49 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { ratio, resizeToSizeRestrictions, getIntersections, coordinatesToPositionRestrictions, moveToPositionRestrictions } from "../service/utils.js";
+import { getTransformedImageSize, getAreaSizeRestrictions } from "../service/helpers.js";
+function defaultVisibleArea(state, settings) {
+  var coordinates = state.coordinates, boundary = state.boundary;
+  var imageSize = getTransformedImageSize(state);
+  var boundaryRatio = ratio(boundary);
+  if (coordinates) {
+    var reference = {
+      height: Math.max(coordinates.height, imageSize.height),
+      width: Math.max(coordinates.width, imageSize.width)
+    };
+    var visibleArea = {
+      left: 0,
+      top: 0,
+      width: ratio(reference) > boundaryRatio ? reference.width : reference.height * boundaryRatio,
+      height: ratio(reference) > boundaryRatio ? reference.width / boundaryRatio : reference.height
+    };
+    visibleArea = resizeToSizeRestrictions(visibleArea, getAreaSizeRestrictions(state, settings));
+    visibleArea.left = coordinates.left + coordinates.width / 2 - visibleArea.width / 2;
+    visibleArea.top = coordinates.top + coordinates.height / 2 - visibleArea.height / 2;
+    var coordinatesIntersection = getIntersections(coordinates, coordinatesToPositionRestrictions(__assign({ left: 0, top: 0 }, imageSize)));
+    var restrictions = {};
+    if (!coordinatesIntersection.left && !coordinatesIntersection.right && visibleArea.width <= imageSize.width) {
+      restrictions.left = 0;
+      restrictions.right = imageSize.width;
+    }
+    if (!coordinatesIntersection.top && !coordinatesIntersection.bottom && visibleArea.height <= imageSize.height) {
+      restrictions.top = 0;
+      restrictions.bottom = imageSize.height;
+    }
+    return moveToPositionRestrictions(visibleArea, restrictions);
+  } else {
+    var imageRatio = ratio(imageSize);
+    var areaProperties = {
+      height: imageRatio < boundaryRatio ? imageSize.height : imageSize.width / boundaryRatio,
+      width: imageRatio < boundaryRatio ? imageSize.height * boundaryRatio : imageSize.width
+    };
+    return {
+      left: imageSize.width / 2 - areaProperties.width / 2,
+      top: imageSize.height / 2 - areaProperties.height / 2,
+      width: areaProperties.width,
+      height: areaProperties.height
+    };
+  }
+}
+export {
+  defaultVisibleArea
+};

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

@@ -0,0 +1,84 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { isFunction } from "../utils/index.js";
+import { createAspectRatio } from "../service/utils.js";
+import { mergeSizeRestrictions } from "../service/sizeRestrictions.js";
+import { defaultPositionRestrictions } from "./defaultPositionRestrictions.js";
+import { defaultVisibleArea } from "./defaultVisibleArea.js";
+import { defaultSize } from "./defaultSize.js";
+import { pixelsRestrictions } from "./defaultSizeRestrictions.js";
+import { retrieveSizeRestrictions } from "./defaultSizeRestrictions.js";
+import { defaultPosition } from "./defaultPosition.js";
+import { defaultAreaPositionRestrictions } from "./defaultAreaPositionRestrictions.js";
+import { defaultAreaSizeRestrictions } from "./defaultAreaSizeRestrictions.js";
+function withDefaultSizeRestrictions(sizeRestrictions) {
+  return function(state, basicSettings) {
+    var value = isFunction(sizeRestrictions) ? sizeRestrictions(state, basicSettings) : sizeRestrictions;
+    return mergeSizeRestrictions(pixelsRestrictions(state, basicSettings), value);
+  };
+}
+function createDefaultSettings(params) {
+  return __assign(__assign({}, params), { sizeRestrictions: function(state, basicSettings) {
+    var restrictions;
+    if (params.sizeRestrictions) {
+      restrictions = isFunction(params.sizeRestrictions) ? params.sizeRestrictions(state, basicSettings) : params.sizeRestrictions;
+    } else {
+      restrictions = pixelsRestrictions(state, basicSettings);
+    }
+    return restrictions;
+  }, areaPositionRestrictions: function(state, basicSettings) {
+    if (params.areaPositionRestrictions) {
+      return isFunction(params.areaPositionRestrictions) ? params.areaPositionRestrictions(state, basicSettings) : params.areaPositionRestrictions;
+    } else {
+      return defaultAreaPositionRestrictions(state, basicSettings);
+    }
+  }, areaSizeRestrictions: function(state, basicSettings) {
+    if (params.areaSizeRestrictions) {
+      return isFunction(params.areaSizeRestrictions) ? params.areaSizeRestrictions(state, basicSettings) : params.areaSizeRestrictions;
+    } else {
+      return defaultAreaSizeRestrictions(state, basicSettings);
+    }
+  }, positionRestrictions: function(state, basicSettings) {
+    if (params.positionRestrictions) {
+      return isFunction(params.positionRestrictions) ? params.positionRestrictions(state, basicSettings) : params.positionRestrictions;
+    } else {
+      return defaultPositionRestrictions(state, basicSettings);
+    }
+  }, defaultCoordinates: function(state, basicSettings) {
+    if (params.defaultCoordinates) {
+      return isFunction(params.defaultCoordinates) ? params.defaultCoordinates(state, basicSettings) : params.defaultCoordinates;
+    } else {
+      var defaultSizeAlgorithm = params.defaultSize;
+      if (!defaultSizeAlgorithm) {
+        defaultSizeAlgorithm = defaultSize;
+      }
+      var size = isFunction(defaultSizeAlgorithm) ? defaultSizeAlgorithm(state, basicSettings) : defaultSizeAlgorithm;
+      var defaultPositionAlgorithm_1 = params.defaultPosition || defaultPosition;
+      return [
+        size,
+        function(state2) {
+          return __assign({}, isFunction(defaultPositionAlgorithm_1) ? defaultPositionAlgorithm_1(state2, basicSettings) : defaultPositionAlgorithm_1);
+        }
+      ];
+    }
+  }, defaultVisibleArea: function(state, basicSettings) {
+    if (params.defaultVisibleArea) {
+      return isFunction(params.defaultVisibleArea) ? params.defaultVisibleArea(state, basicSettings) : params.defaultVisibleArea;
+    } else {
+      return defaultVisibleArea(state, basicSettings);
+    }
+  }, aspectRatio: function(state, basicSettings) {
+    return createAspectRatio(isFunction(params.aspectRatio) ? params.aspectRatio(state, basicSettings) : params.aspectRatio);
+  } });
+}
+export {
+  createDefaultSettings,
+  defaultAreaPositionRestrictions,
+  defaultAreaSizeRestrictions,
+  defaultPosition,
+  defaultPositionRestrictions,
+  defaultSize,
+  defaultVisibleArea,
+  pixelsRestrictions,
+  retrieveSizeRestrictions,
+  withDefaultSizeRestrictions
+};

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/extensions/stencil-size/index.js

@@ -0,0 +1,107 @@
+import { __assign } from "../../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { isFunction } from "../../utils/index.js";
+import { ratio, aspectRatioIntersection, createAspectRatio, applyScale, fitToSizeRestrictions, applyMove, diff, getCenter, moveToPositionRestrictions, mergePositionRestrictions, coordinatesToPositionRestrictions } from "../../service/utils.js";
+import { getSizeRestrictions, getAspectRatio, getAreaSizeRestrictions, isInitializedState, getAreaPositionRestrictions } from "../../service/helpers.js";
+import { copyState } from "../../state/copyState.js";
+import { approximateSize } from "../../service/approximateSize.js";
+import { defaultStencilConstraints } from "../../defaults/defaultStencilConstraints.js";
+function fixedStencilConstraints(rawSettings, stencilOptions) {
+  var defaultConstraints = defaultStencilConstraints({}, stencilOptions);
+  return {
+    stencilSize: function(state, settings) {
+      var previousSize = isFunction(rawSettings.stencilSize) ? rawSettings.stencilSize(state, settings) : rawSettings.stencilSize;
+      return approximateSize(__assign(__assign({}, previousSize), { aspectRatio: aspectRatioIntersection(defaultConstraints.aspectRatio, createAspectRatio(ratio(previousSize))) }));
+    }
+  };
+}
+function getStencilSize(state, settings) {
+  var boundary = state.boundary;
+  var size = isFunction(settings.stencilSize) ? settings.stencilSize(state, settings) : settings.stencilSize;
+  if (size.width > boundary.width || size.height > boundary.height) {
+    size = approximateSize({
+      sizeRestrictions: {
+        maxWidth: boundary.width,
+        maxHeight: boundary.height,
+        minWidth: 0,
+        minHeight: 0
+      },
+      width: size.width,
+      height: size.height,
+      aspectRatio: {
+        minimum: ratio(size),
+        maximum: ratio(size)
+      }
+    });
+  }
+  return size;
+}
+function sizeRestrictions(state, settings) {
+  var stencilSize = getStencilSize(state, __assign(__assign({}, settings), { stencilSize: settings.stencilSize }));
+  var areaRestrictions = getAreaSizeRestrictions(state, settings);
+  return {
+    maxWidth: areaRestrictions.maxWidth * stencilSize.width / state.boundary.width,
+    maxHeight: areaRestrictions.maxHeight * stencilSize.height / state.boundary.height,
+    minWidth: 0,
+    minHeight: 0
+  };
+}
+function defaultSize(state, settings) {
+  var imageSize = state.imageSize, visibleArea = state.visibleArea, boundary = state.boundary;
+  var sizeRestrictions2 = getSizeRestrictions(state, settings);
+  var aspectRatio2 = getAspectRatio(state, settings);
+  var stencilSize = isFunction(settings.stencilSize) ? settings.stencilSize(state, settings) : settings.stencilSize;
+  var area = visibleArea || imageSize;
+  var height, width;
+  if (ratio(area) > ratio(boundary)) {
+    height = stencilSize.height * area.height / boundary.height;
+    width = height * ratio(stencilSize);
+  } else {
+    width = stencilSize.width * area.width / boundary.width;
+    height = width / ratio(stencilSize);
+  }
+  return approximateSize({
+    width,
+    height,
+    aspectRatio: aspectRatio2,
+    sizeRestrictions: sizeRestrictions2
+  });
+}
+function aspectRatio(state, settings) {
+  var value = ratio(getStencilSize(state, settings));
+  return {
+    minimum: value,
+    maximum: value
+  };
+}
+function fixedStencilAlgorithm(state, settings) {
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    var stencil = getStencilSize(state, settings);
+    result.visibleArea = applyScale(result.visibleArea, result.coordinates.width * result.boundary.width / (result.visibleArea.width * stencil.width));
+    var scale = fitToSizeRestrictions(result.visibleArea, getAreaSizeRestrictions(result, settings));
+    if (scale !== 1) {
+      result.visibleArea = applyScale(result.visibleArea, scale);
+      result.coordinates = applyScale(result.coordinates, scale);
+    }
+    result.visibleArea = applyMove(result.visibleArea, diff(getCenter(result.coordinates), getCenter(result.visibleArea)));
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+    result.coordinates = moveToPositionRestrictions(result.coordinates, mergePositionRestrictions(coordinatesToPositionRestrictions(result.visibleArea), getAreaPositionRestrictions(result, settings)));
+    return result;
+  }
+  return state;
+}
+function fixedStencil(state, settings, action) {
+  if (action && action.immediately) {
+    return fixedStencilAlgorithm(state, settings);
+  }
+  return state;
+}
+export {
+  aspectRatio,
+  defaultSize,
+  fixedStencil,
+  fixedStencilAlgorithm,
+  fixedStencilConstraints,
+  getStencilSize,
+  sizeRestrictions
+};