dune-react 0.0.43 → 0.0.44

package/dist/node_modules/.pnpm/advanced-cropper@0.17.1/node_modules/advanced-cropper/instance/AbstractCropperInstance.js

@@ -0,0 +1,494 @@
+import { __assign, __rest, __spreadArrays } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { getOptions, deepClone, debounce, isArray, isFunction, deepCompare, isUndefined, isObject } from "../utils/index.js";
+import { getCoefficient, isConsistentState, getStencilCoordinates, getRoundedCoordinates } from "../service/helpers.js";
+import { copyState } from "../state/copyState.js";
+import { setCoordinates, SetCoordinatesMode } from "../state/setCoordinates.js";
+import { setVisibleArea } from "../state/setVisibleArea.js";
+import { createState } from "../state/createState.js";
+import { moveCoordinates } from "../state/moveCoordinates.js";
+import { resizeCoordinates } from "../state/resizeCoordinates.js";
+import { setBoundary } from "../state/setBoundary.js";
+import { transformImage } from "../state/transformImage.js";
+import { reconcileState } from "../state/reconcileState.js";
+import { normalizeImageTransform, normalizeFlip, normalizeMoveDirections, fillMoveDirections, normalizeResizeDirections, fillResizeDirections } from "../service/normalize.js";
+import { hasInteractions } from "../service/interactions.js";
+function runCallback(callback, getInstance) {
+  if (callback && getInstance) {
+    var instance = getInstance();
+    if (instance) {
+      callback(instance);
+    }
+  }
+}
+function runCallbacks(callbacks, getInstance) {
+  callbacks.forEach(function(callback) {
+    runCallback(callback, getInstance);
+  });
+}
+var AbstractCropperInstance = (
+  /** @class */
+  /* @__PURE__ */ function() {
+    function AbstractCropperInstance2() {
+      var _this = this;
+      this.getTransitions = function() {
+        var data = _this.getData();
+        var transitions = _this.getProps().transitions;
+        return __assign(__assign({}, getOptions(transitions, {
+          timingFunction: "ease-in-out",
+          duration: 350
+        })), { active: data.transitions });
+      };
+      this.getInteractions = function() {
+        var interactions = _this.getData().interactions;
+        return deepClone(interactions);
+      };
+      this.hasInteractions = function() {
+        var interactions = _this.getData().interactions;
+        return hasInteractions(interactions);
+      };
+      this.startTransitions = function() {
+        var _a = _this.getProps(), onTransitionsStart = _a.onTransitionsStart, onUpdate = _a.onUpdate, getInstance = _a.getInstance;
+        var _b = _this.getData(), transitions = _b.transitions, data = __rest(_b, ["transitions"]);
+        _this.setData(__assign(__assign({}, data), { transitions: true }));
+        if (!transitions) {
+          runCallbacks([onTransitionsStart, onUpdate], getInstance);
+        }
+        _this.endTransitions();
+      };
+      this.endTransitions = debounce(function() {
+        var _a = _this.getProps(), onTransitionsEnd = _a.onTransitionsEnd, onUpdate = _a.onUpdate, getInstance = _a.getInstance;
+        _this.setData(__assign(__assign({}, _this.getData()), { transitions: false }));
+        runCallbacks([onTransitionsEnd, onUpdate], getInstance);
+      }, function() {
+        return _this.getTransitions().duration;
+      });
+      this.applyPostProcess = function(action, state) {
+        var _a = _this.getProps(), settings = _a.settings, postProcess = _a.postProcess;
+        var name = action.name, _b = action.interaction, interaction = _b === void 0 ? false : _b, _c = action.transitions, transitions = _c === void 0 ? false : _c, _d = action.immediately, immediately = _d === void 0 ? false : _d;
+        var preparedAction = {
+          name,
+          interaction,
+          transitions,
+          immediately
+        };
+        if (isArray(postProcess)) {
+          return postProcess.reduce(function(processedState, p) {
+            return p(processedState, settings, preparedAction);
+          }, state);
+        } else if (isFunction(postProcess)) {
+          return postProcess(state, settings, preparedAction);
+        } else {
+          return state;
+        }
+      };
+      this.updateState = function(modifier, options, callbacks) {
+        if (options === void 0) {
+          options = {};
+        }
+        if (callbacks === void 0) {
+          callbacks = [];
+        }
+        var _a = options.transitions, transitions = _a === void 0 ? false : _a;
+        var _b = _this.getProps(), onTransitionsStart = _b.onTransitionsStart, getInstance = _b.getInstance, onChange = _b.onChange, onUpdate = _b.onUpdate, settings = _b.settings;
+        var previousData = _this.getData();
+        var state = isFunction(modifier) ? modifier(previousData.state, settings) : modifier;
+        var tolerance = state ? 1e-3 * getCoefficient(state) : 1e-3;
+        var somethingChanged = !deepCompare(previousData.state, state, tolerance);
+        var affectTransitionProperties = [
+          "coordinates",
+          "boundary",
+          "visibleArea",
+          "imageSize",
+          "transforms"
+        ].some(function(property) {
+          var _a2;
+          return !deepCompare((_a2 = previousData.state) === null || _a2 === void 0 ? void 0 : _a2[property], state === null || state === void 0 ? void 0 : state[property], tolerance);
+        });
+        var currentData = previousData;
+        if (somethingChanged) {
+          if (transitions && affectTransitionProperties) {
+            _this.endTransitions();
+          }
+          currentData = __assign(__assign({}, currentData), { state: copyState(state), transitions: transitions && affectTransitionProperties });
+          _this.setData(currentData);
+          runCallback(onChange, getInstance);
+        }
+        if (currentData.transitions && !previousData.transitions) {
+          runCallback(onTransitionsStart, getInstance);
+        }
+        runCallbacks(__spreadArrays(callbacks, [onUpdate]), getInstance);
+      };
+      this.setInteractions = function(interactions) {
+        var _a = _this.getProps(), onInteractionStart = _a.onInteractionStart, onInteractionEnd = _a.onInteractionEnd, getInstance = _a.getInstance;
+        var previousInteractions = _this.getInteractions();
+        var currentInteractions = __assign(__assign({}, previousInteractions), interactions);
+        if (!deepCompare(previousInteractions, currentInteractions)) {
+          _this.setData(__assign(__assign({}, _this.getData()), { interactions: currentInteractions }));
+        }
+        if (hasInteractions(previousInteractions) !== hasInteractions(currentInteractions)) {
+          if (!hasInteractions(previousInteractions)) {
+            runCallback(onInteractionStart, getInstance);
+          } else {
+            var state_1 = _this.getData().state;
+            _this.updateState(function() {
+              return state_1 && _this.applyPostProcess({
+                name: "interactionEnd",
+                immediately: true,
+                transitions: true
+              }, state_1);
+            }, {
+              transitions: true
+            }, [onInteractionEnd]);
+          }
+        }
+      };
+      this.resetState = function(boundary, image) {
+        _this.updateState(_this.createDefaultState(boundary, image));
+      };
+      this.clear = function() {
+        _this.updateState(null);
+      };
+      this.reconcileState = function(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = _this.getProps(), reconcileStateAlgorithm = _a.reconcileStateAlgorithm, settings = _a.settings;
+        var state = _this.getData().state;
+        var _b = options.transitions, transitions = _b === void 0 ? false : _b;
+        if (state && !isConsistentState(state, settings)) {
+          var reconciledState = (reconcileStateAlgorithm || reconcileState)(state, settings);
+          reconciledState = _this.applyPostProcess({
+            name: "reconcileState",
+            immediately: true,
+            transitions
+          }, reconciledState);
+          _this.updateState(reconciledState, {
+            transitions
+          });
+        }
+      };
+      this.transformImage = function(transform, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.transitions, transitions = _a === void 0 ? true : _a, _b = options.interaction, interaction = _b === void 0 ? true : _b, _c = options.immediately, immediately = _c === void 0 ? false : _c, _d = options.normalize, normalize = _d === void 0 ? true : _d;
+        var _e = _this.getProps(), transformImageAlgorithm = _e.transformImageAlgorithm, onTransformImage = _e.onTransformImage, onTransformImageEnd = _e.onTransformImageEnd, settings = _e.settings;
+        var state = _this.getData().state;
+        var callbacks = [];
+        if (state) {
+          if (normalize) {
+            transform = normalizeImageTransform(state, transform);
+          }
+          var result = _this.applyPostProcess({
+            name: "transformImage",
+            transitions,
+            immediately
+          }, (transformImageAlgorithm || transformImage)(state, settings, transform));
+          callbacks.push(onTransformImage);
+          if (interaction) {
+            _this.setInteractions({
+              transformImage: {
+                rotate: !isUndefined(transform.rotate),
+                flip: !isUndefined(transform.flip),
+                scale: !isUndefined(transform.scale),
+                move: !isUndefined(transform.move)
+              }
+            });
+          } else {
+            result = _this.applyPostProcess({
+              name: "transformImageEnd",
+              transitions,
+              immediately: true
+            }, result);
+            callbacks.push(onTransformImageEnd);
+          }
+          _this.updateState(result, {
+            transitions: immediately && transitions
+          }, callbacks);
+        }
+      };
+      this.transformImageEnd = function(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.immediately, immediately = _a === void 0 ? true : _a, _b = options.transitions, transitions = _b === void 0 ? true : _b;
+        var state = _this.getData().state;
+        var onTransformImageEnd = _this.getProps().onTransformImageEnd;
+        _this.updateState(function() {
+          return state && _this.applyPostProcess({ name: "transformImageEnd", immediately, transitions }, state);
+        }, {
+          transitions
+        }, [onTransformImageEnd]);
+        _this.setInteractions({
+          transformImage: {
+            rotate: false,
+            flip: false,
+            scale: false,
+            move: false
+          }
+        });
+      };
+      this.zoomImage = function(scale, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.interaction, interaction = _a === void 0 ? false : _a, _b = options.immediately, immediately = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? true : _c, _d = options.normalize, normalize = _d === void 0 ? false : _d;
+        _this.transformImage({
+          scale
+        }, { interaction, immediately, transitions, normalize });
+      };
+      this.moveImage = function(left, top, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.interaction, interaction = _a === void 0 ? false : _a, _b = options.immediately, immediately = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? true : _c, _d = options.normalize, normalize = _d === void 0 ? false : _d;
+        _this.transformImage({
+          move: {
+            left,
+            top
+          }
+        }, { interaction, immediately, transitions, normalize });
+      };
+      this.flipImage = function(horizontal, vertical, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.interaction, interaction = _a === void 0 ? false : _a, _b = options.immediately, immediately = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? true : _c, _d = options.normalize, normalize = _d === void 0 ? true : _d;
+        var state = _this.getState();
+        var flip = {
+          horizontal,
+          vertical
+        };
+        _this.transformImage({
+          flip: state && normalize ? normalizeFlip(state, flip) : flip
+        }, { interaction, immediately, transitions });
+      };
+      this.rotateImage = function(rotate, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.interaction, interaction = _a === void 0 ? false : _a, _b = options.immediately, immediately = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? true : _c, _d = options.normalize, normalize = _d === void 0 ? false : _d;
+        _this.transformImage({
+          rotate
+        }, { interaction, immediately, transitions, normalize });
+      };
+      this.reset = function(boundary, image) {
+        _this.resetState(boundary, image);
+      };
+      this.setState = function(modifier, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var settings = _this.getSettings();
+        var state = _this.getData().state;
+        var _a = options.transitions, transitions = _a === void 0 ? true : _a, _b = options.immediately, immediately = _b === void 0 ? false : _b, _c = options.interaction, interaction = _c === void 0 ? false : _c, _d = options.postprocess, postprocess = _d === void 0 ? false : _d;
+        var newState = modifier && (isFunction(modifier) ? modifier(state, settings) : __assign(__assign({}, state), modifier));
+        _this.updateState(function() {
+          return postprocess ? newState && _this.applyPostProcess({
+            name: "setState",
+            immediately,
+            transitions,
+            interaction
+          }, newState) : newState;
+        }, {
+          transitions
+        });
+      };
+      this.setCoordinates = function(transforms, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var state = _this.getData().state;
+        var _a = _this.getProps(), setCoordinatesAlgorithm = _a.setCoordinatesAlgorithm, settings = _a.settings;
+        var _b = options.transitions, transitions = _b === void 0 ? true : _b, _c = options.immediately, immediately = _c === void 0 ? true : _c;
+        _this.updateState(function() {
+          return state && _this.applyPostProcess({
+            name: "setCoordinates",
+            immediately,
+            transitions
+          }, (setCoordinatesAlgorithm || setCoordinates)(state, settings, transforms, SetCoordinatesMode.zoom));
+        }, {
+          transitions
+        });
+      };
+      this.setVisibleArea = function(visibleArea, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a = options.transitions, transitions = _a === void 0 ? true : _a, _b = options.immediately, immediately = _b === void 0 ? true : _b;
+        var state = _this.getData().state;
+        var _c = _this.getProps(), setVisibleAreaAlgorithm = _c.setVisibleAreaAlgorithm, settings = _c.settings;
+        _this.updateState(function() {
+          return state && _this.applyPostProcess({ name: "setVisibleArea", immediately, transitions }, (setVisibleAreaAlgorithm || setVisibleArea)(state, settings, visibleArea));
+        }, {
+          transitions
+        });
+      };
+      this.setBoundary = function(boundary, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var state = _this.getData().state;
+        var _a = _this.getProps(), setBoundaryAlgorithm = _a.setBoundaryAlgorithm, settings = _a.settings;
+        var _b = options.transitions, transitions = _b === void 0 ? false : _b, _c = options.immediately, immediately = _c === void 0 ? true : _c;
+        if (boundary) {
+          _this.updateState(function() {
+            return state && _this.applyPostProcess({ name: "setBoundary", immediately, transitions }, (setBoundaryAlgorithm || setBoundary)(state, settings, boundary));
+          });
+        } else {
+          _this.updateState(null);
+        }
+      };
+      this.moveCoordinates = function(directions, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var data = _this.getData();
+        var _a = _this.getProps(), moveCoordinatesAlgorithm = _a.moveCoordinatesAlgorithm, onMove = _a.onMove, onMoveEnd = _a.onMoveEnd, settings = _a.settings;
+        var _b = options.interaction, interaction = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? false : _c, _d = options.immediately, immediately = _d === void 0 ? false : _d, _e = options.normalize, normalize = _e === void 0 ? true : _e;
+        var callbacks = [];
+        if (!data.transitions && data.state) {
+          var normalizedDirections = normalize ? normalizeMoveDirections(data.state, directions) : fillMoveDirections(directions);
+          var result = _this.applyPostProcess({ name: "moveCoordinates", interaction, immediately, transitions }, (moveCoordinatesAlgorithm || moveCoordinates)(data.state, settings, normalizedDirections));
+          callbacks.push(onMove);
+          if (interaction) {
+            _this.setInteractions({
+              moveCoordinates: true
+            });
+          } else {
+            result = _this.applyPostProcess({ name: "moveCoordinatesEnd", interaction, immediately, transitions }, result);
+            callbacks.push(onMoveEnd);
+          }
+          _this.updateState(result, {
+            transitions: immediately && transitions
+          }, callbacks);
+        }
+      };
+      this.moveCoordinatesEnd = function(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var state = _this.getData().state;
+        var onMoveEnd = _this.getProps().onMoveEnd;
+        var _a = options.transitions, transitions = _a === void 0 ? true : _a, _b = options.immediately, immediately = _b === void 0 ? false : _b;
+        _this.updateState(function() {
+          return state && _this.applyPostProcess({ name: "moveCoordinatesEnd", transitions, immediately }, state);
+        }, {
+          transitions
+        }, [onMoveEnd]);
+        _this.setInteractions({
+          moveCoordinates: false
+        });
+      };
+      this.resizeCoordinates = function(anchor, directions, parameters, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var state = _this.getData().state;
+        var _a = _this.getProps(), resizeCoordinatesAlgorithm = _a.resizeCoordinatesAlgorithm, onResize = _a.onResize, onResizeEnd = _a.onResizeEnd, settings = _a.settings;
+        var _b = options.interaction, interaction = _b === void 0 ? true : _b, _c = options.transitions, transitions = _c === void 0 ? false : _c, _d = options.immediately, immediately = _d === void 0 ? false : _d, _e = options.normalize, normalize = _e === void 0 ? true : _e;
+        var transitionsOptions = _this.getTransitions();
+        if (!transitionsOptions.active && state) {
+          var callbacks = [];
+          var normalizedDirections = normalize ? normalizeResizeDirections(state, directions) : fillResizeDirections(directions);
+          var result = _this.applyPostProcess({ name: "resizeCoordinates", interaction, immediately, transitions }, (resizeCoordinatesAlgorithm || resizeCoordinates)(state, settings, anchor, normalizedDirections, isObject(parameters) ? parameters : {}));
+          callbacks.push(onResize);
+          if (interaction) {
+            _this.setInteractions({
+              resizeCoordinates: true
+            });
+          } else {
+            result = _this.applyPostProcess({ name: "resizeCoordinatesEnd", interaction, immediately, transitions }, result);
+            callbacks.push(onResizeEnd);
+          }
+          _this.updateState(result, {
+            transitions: immediately && transitions
+          }, callbacks);
+        }
+      };
+      this.resizeCoordinatesEnd = function(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var onResizeEnd = _this.getProps().onResizeEnd;
+        var state = _this.getData().state;
+        var _a = options.transitions, transitions = _a === void 0 ? true : _a, _b = options.immediately, immediately = _b === void 0 ? false : _b;
+        _this.updateState(function() {
+          return state && _this.applyPostProcess({ name: "resizeCoordinatesEnd", transitions, immediately }, state);
+        }, {
+          transitions
+        }, [onResizeEnd]);
+        _this.setInteractions({
+          resizeCoordinates: false
+        });
+      };
+      this.getStencilCoordinates = function() {
+        var state = _this.getData().state;
+        return getStencilCoordinates(state);
+      };
+      this.getCoordinates = function(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var state = _this.getData().state;
+        var settings = _this.getProps().settings;
+        if (state && state.coordinates) {
+          var _a = options.round, round = _a === void 0 ? true : _a;
+          if (round) {
+            return getRoundedCoordinates(state, settings);
+          } else {
+            return __assign({}, state.coordinates);
+          }
+        } else {
+          return null;
+        }
+      };
+      this.getVisibleArea = function() {
+        var state = _this.getData().state;
+        if (state === null || state === void 0 ? void 0 : state.visibleArea) {
+          return __assign({}, state.visibleArea);
+        } else {
+          return null;
+        }
+      };
+      this.getSettings = function() {
+        var settings = _this.getProps().settings;
+        return __assign({}, settings);
+      };
+      this.getState = function() {
+        var state = _this.getData().state;
+        return copyState(state);
+      };
+      this.getTransforms = function() {
+        var state = _this.getData().state;
+        return state ? deepClone(state.transforms) : {
+          rotate: 0,
+          flip: {
+            horizontal: false,
+            vertical: false
+          }
+        };
+      };
+      this.createDefaultState = function(boundary, image) {
+        var _a = _this.getProps(), createStateAlgorithm = _a.createStateAlgorithm, settings = _a.settings;
+        return _this.applyPostProcess({
+          name: "createState",
+          immediately: true,
+          transitions: false
+        }, (createStateAlgorithm || createState)({
+          image,
+          boundary
+        }, settings));
+      };
+      this.isConsistent = function() {
+        var state = _this.getData().state;
+        var settings = _this.getProps().settings;
+        return state ? isConsistentState(state, settings) : true;
+      };
+    }
+    return AbstractCropperInstance2;
+  }()
+);
+export {
+  AbstractCropperInstance
+};

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

@@ -0,0 +1,30 @@
+import { createAspectRatio, resizeToSizeRestrictions, getCloserSize } from "./utils.js";
+function approximateSize(params) {
+  var width = params.width, height = params.height;
+  var sizeRestrictions = params.sizeRestrictions || {
+    minWidth: 0,
+    minHeight: 0,
+    maxWidth: Infinity,
+    maxHeight: Infinity
+  };
+  var aspectRatio = createAspectRatio(params.aspectRatio);
+  var coordinates = {
+    width: Math.max(sizeRestrictions.minWidth, Math.min(sizeRestrictions.maxWidth, width)),
+    height: Math.max(sizeRestrictions.minHeight, Math.min(sizeRestrictions.maxHeight, height))
+  };
+  var candidates = [coordinates];
+  if (aspectRatio) {
+    [aspectRatio.minimum, aspectRatio.maximum].forEach(function(ratio) {
+      if (ratio) {
+        candidates.push({ width: coordinates.width, height: coordinates.width / ratio }, { width: coordinates.height * ratio, height: coordinates.height });
+      }
+    });
+  }
+  candidates = candidates.map(function(candidate) {
+    return resizeToSizeRestrictions(candidate, sizeRestrictions);
+  });
+  return getCloserSize(candidates, { width, height }, sizeRestrictions, aspectRatio);
+}
+export {
+  approximateSize
+};

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

@@ -0,0 +1,30 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { applyMove, diff, getCenter, moveToPositionRestrictions, mergePositionRestrictions, coordinatesToPositionRestrictions } from "./utils.js";
+import { getAspectRatio, getSizeRestrictions, getPositionRestrictions } from "./helpers.js";
+import { copyState } from "../state/copyState.js";
+import { approximateSize } from "./approximateSize.js";
+function fitCoordinates(state, settings) {
+  if (state.coordinates) {
+    var result = copyState(state);
+    var aspectRatio = getAspectRatio(state, settings);
+    var sizeRestrictions = getSizeRestrictions(state, settings);
+    result.coordinates = __assign(__assign({}, state.coordinates), approximateSize({
+      width: state.coordinates.width,
+      height: state.coordinates.height,
+      aspectRatio,
+      sizeRestrictions: state.visibleArea ? {
+        maxWidth: Math.min(state.visibleArea.width, sizeRestrictions.maxWidth),
+        maxHeight: Math.min(state.visibleArea.height, sizeRestrictions.maxHeight),
+        minHeight: Math.min(state.visibleArea.height, sizeRestrictions.minHeight),
+        minWidth: Math.min(state.visibleArea.width, sizeRestrictions.minWidth)
+      } : sizeRestrictions
+    }));
+    result.coordinates = applyMove(result.coordinates, diff(getCenter(state.coordinates), getCenter(result.coordinates)));
+    result.coordinates = moveToPositionRestrictions(result.coordinates, state.visibleArea ? mergePositionRestrictions(coordinatesToPositionRestrictions(state.visibleArea), getPositionRestrictions(result, settings)) : getPositionRestrictions(result, settings));
+    return result;
+  }
+  return state;
+}
+export {
+  fitCoordinates
+};

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

@@ -0,0 +1,26 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { ratio, applyMove, diff, getCenter, moveToPositionRestrictions } from "./utils.js";
+import { getAreaSizeRestrictions, getAreaPositionRestrictions } from "./helpers.js";
+import { copyState } from "../state/copyState.js";
+import { approximateSize } from "./approximateSize.js";
+function fitVisibleArea(state, settings) {
+  var result = copyState(state);
+  if (state.visibleArea) {
+    var areaSizeRestrictions = getAreaSizeRestrictions(state, settings);
+    result.visibleArea = __assign(__assign({}, state.visibleArea), approximateSize({
+      width: state.visibleArea.width,
+      height: state.visibleArea.height,
+      aspectRatio: {
+        minimum: ratio(result.boundary),
+        maximum: ratio(result.boundary)
+      },
+      sizeRestrictions: areaSizeRestrictions
+    }));
+    result.visibleArea = applyMove(result.visibleArea, diff(getCenter(state.visibleArea), getCenter(result.visibleArea)));
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+  }
+  return result;
+}
+export {
+  fitVisibleArea
+};