dune-react 0.0.43 → 0.0.45

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

@@ -0,0 +1,41 @@
+import { getDefaultTransforms, getDefaultVisibleArea, getDefaultCoordinates } from "../service/helpers.js";
+import { Priority } from "../types/index.js";
+import { setCoordinates, SetCoordinatesMode } from "./setCoordinates.js";
+import { setVisibleArea } from "./setVisibleArea.js";
+function createState(options, settings) {
+  var _a, _b, _c, _d, _e;
+  var boundary = options.boundary, image = options.image;
+  var state = {
+    boundary: {
+      width: boundary.width,
+      height: boundary.height
+    },
+    imageSize: {
+      width: image.width,
+      height: image.height
+    },
+    transforms: {
+      rotate: ((_a = image.transforms) === null || _a === void 0 ? void 0 : _a.rotate) || 0,
+      flip: {
+        horizontal: ((_c = (_b = image.transforms) === null || _b === void 0 ? void 0 : _b.flip) === null || _c === void 0 ? void 0 : _c.horizontal) || false,
+        vertical: ((_e = (_d = image.transforms) === null || _d === void 0 ? void 0 : _d.flip) === null || _e === void 0 ? void 0 : _e.vertical) || false
+      }
+    },
+    visibleArea: null,
+    coordinates: null
+  };
+  if (settings.defaultTransforms) {
+    state.transforms = getDefaultTransforms(state, settings);
+  }
+  if (settings.priority === Priority.visibleArea) {
+    state = setVisibleArea(state, settings, getDefaultVisibleArea(state, settings), false);
+    state = setCoordinates(state, settings, getDefaultCoordinates(state, settings), SetCoordinatesMode.limit);
+  } else {
+    state = setCoordinates(state, settings, getDefaultCoordinates(state, settings), SetCoordinatesMode.unsafe);
+    state = setVisibleArea(state, settings, getDefaultVisibleArea(state, settings), true);
+  }
+  return state;
+}
+export {
+  createState
+};

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

@@ -0,0 +1,15 @@
+import { applyMove, moveToPositionRestrictions, mergePositionRestrictions, coordinatesToPositionRestrictions } from "../service/utils.js";
+import { isInitializedState, getPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "./copyState.js";
+function moveCoordinates(state, settings, directions) {
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    result.coordinates = applyMove(result.coordinates, directions);
+    result.coordinates = moveToPositionRestrictions(result.coordinates, mergePositionRestrictions(coordinatesToPositionRestrictions(result.visibleArea), getPositionRestrictions(result, settings)));
+    return result;
+  }
+  return state;
+}
+export {
+  moveCoordinates
+};

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

@@ -0,0 +1,44 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { getBrokenRatio, ratio, applyMove, diff, getCenter, moveToPositionRestrictions, mergePositionRestrictions, coordinatesToPositionRestrictions } from "../service/utils.js";
+import { mergeSizeRestrictions } from "../service/sizeRestrictions.js";
+import { isInitializedState, getAspectRatio, getSizeRestrictions, getAreaSizeRestrictions, getAreaPositionRestrictions, getPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "./copyState.js";
+import { approximateSize } from "../service/approximateSize.js";
+function reconcileState(state, settings) {
+  if (isInitializedState(state)) {
+    var result = copyState(state);
+    var aspectRatio = getAspectRatio(state, settings);
+    var sizeRestrictions = getSizeRestrictions(state, settings);
+    var areaSizeRestrictions = getAreaSizeRestrictions(state, settings);
+    var brokenRatio = getBrokenRatio(ratio(state.coordinates), aspectRatio);
+    var desiredSize = brokenRatio ? {
+      height: state.coordinates.height,
+      width: state.coordinates.height * brokenRatio
+    } : state.coordinates;
+    result.coordinates = __assign(__assign({}, result.coordinates), approximateSize({
+      width: desiredSize.width,
+      height: desiredSize.height,
+      aspectRatio,
+      sizeRestrictions: mergeSizeRestrictions(areaSizeRestrictions, sizeRestrictions)
+    }));
+    result.coordinates = applyMove(result.coordinates, diff(getCenter(state.coordinates), getCenter(result.coordinates)));
+    var scaleModifier = Math.max(result.coordinates.width / result.visibleArea.width, result.coordinates.height / result.visibleArea.height, 1);
+    result.visibleArea = __assign(__assign({}, state.visibleArea), approximateSize({
+      width: state.visibleArea.width * scaleModifier,
+      height: state.visibleArea.height * scaleModifier,
+      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));
+    result.coordinates = moveToPositionRestrictions(result.coordinates, mergePositionRestrictions(coordinatesToPositionRestrictions(result.visibleArea), getPositionRestrictions(result, settings)));
+    return result;
+  }
+  return state;
+}
+export {
+  reconcileState
+};

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

@@ -0,0 +1,22 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { mergePositionRestrictions, coordinatesToPositionRestrictions } from "../service/utils.js";
+import { getMinimumSize, getSizeRestrictions, isInitializedState, getAspectRatio, getPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "./copyState.js";
+import { anchoredResizeCoordinatesAlgorithm } from "../algorithms/resizeCoordinatesAlgorithm.js";
+function resizeCoordinates(state, settings, anchor, directions, options) {
+  var minimumSize = getMinimumSize(state);
+  var sizeRestrictions = getSizeRestrictions(state, settings);
+  return isInitializedState(state) ? __assign(__assign({}, copyState(state)), { coordinates: anchoredResizeCoordinatesAlgorithm(state.coordinates, anchor, directions, options, {
+    positionRestrictions: mergePositionRestrictions(getPositionRestrictions(state, settings), coordinatesToPositionRestrictions(state.visibleArea)),
+    sizeRestrictions: {
+      maxWidth: Math.min(sizeRestrictions.maxWidth, state.visibleArea.width),
+      maxHeight: Math.min(sizeRestrictions.maxHeight, state.visibleArea.height),
+      minWidth: Math.max(Math.min(sizeRestrictions.minWidth, state.visibleArea.width), minimumSize),
+      minHeight: Math.max(Math.min(sizeRestrictions.minHeight, state.visibleArea.height), minimumSize)
+    },
+    aspectRatio: getAspectRatio(state, settings)
+  }) }) : state;
+}
+export {
+  resizeCoordinates
+};

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

@@ -0,0 +1,31 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { ratio, applyScale, resizeToSizeRestrictions, inverseMove, fitToPositionRestrictions, coordinatesToPositionRestrictions, applyMove, moveToPositionRestrictions } from "../service/utils.js";
+import { getSizeRestrictions, getAreaSizeRestrictions, getAreaPositionRestrictions } from "../service/helpers.js";
+import { copyState } from "./copyState.js";
+import { fitCoordinates } from "../service/fitCoordinates.js";
+function setBoundary(state, settings, boundary) {
+  var result = __assign(__assign({}, copyState(state)), { boundary });
+  if (result.visibleArea && result.coordinates && state.visibleArea) {
+    result.visibleArea.height = result.visibleArea.width / ratio(boundary);
+    result.visibleArea.top += (state.visibleArea.height - result.visibleArea.height) / 2;
+    var sizeRestrictions = getSizeRestrictions(result, settings);
+    if (Math.max(sizeRestrictions.minHeight, result.coordinates.height) - result.visibleArea.height > 0 || Math.max(sizeRestrictions.minWidth, result.coordinates.width) - result.visibleArea.width > 0) {
+      result.visibleArea = applyScale(result.visibleArea, Math.max(Math.max(sizeRestrictions.minHeight, result.coordinates.height) / result.visibleArea.height, Math.max(sizeRestrictions.minWidth, result.coordinates.width) / result.visibleArea.width));
+    }
+    result.visibleArea = resizeToSizeRestrictions(result.visibleArea, getAreaSizeRestrictions(result, settings));
+    var move = inverseMove(fitToPositionRestrictions(result.coordinates, coordinatesToPositionRestrictions(result.visibleArea)));
+    if (result.visibleArea.width < result.coordinates.width) {
+      move.left = 0;
+    }
+    if (result.visibleArea.height < result.coordinates.height) {
+      move.top = 0;
+    }
+    result.visibleArea = applyMove(result.visibleArea, move);
+    result.visibleArea = moveToPositionRestrictions(result.visibleArea, getAreaPositionRestrictions(result, settings));
+    result = fitCoordinates(result, settings);
+  }
+  return result;
+}
+export {
+  setBoundary
+};

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

@@ -0,0 +1,83 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { emptyCoordinates, isUndefined } from "../utils/index.js";
+import { mergePositionRestrictions, coordinatesToPositionRestrictions, applyScale, maxScale, applyMove, inverseMove, fitToPositionRestrictions } from "../service/utils.js";
+import { getAspectRatio, getSizeRestrictions, getPositionRestrictions, getAreaSizeRestrictions } from "../service/helpers.js";
+import { copyState } from "./copyState.js";
+import { approximateSize } from "../service/approximateSize.js";
+import { fitVisibleArea } from "../service/fitVisibleArea.js";
+import { moveCoordinatesAlgorithm } from "../algorithms/moveCoordinatesAlgorithm.js";
+var SetCoordinatesMode;
+(function(SetCoordinatesMode2) {
+  SetCoordinatesMode2["limit"] = "limit";
+  SetCoordinatesMode2["zoom"] = "zoom";
+  SetCoordinatesMode2["unsafe"] = "unsafe";
+})(SetCoordinatesMode || (SetCoordinatesMode = {}));
+function setCoordinates(state, settings, transform, mode) {
+  if (mode === void 0) {
+    mode = true;
+  }
+  var currentMode = mode === false ? SetCoordinatesMode.unsafe : mode === true ? SetCoordinatesMode.zoom : mode;
+  var aspectRatio = getAspectRatio(state, settings);
+  var sizeRestrictions = getSizeRestrictions(state, settings);
+  if (state.visibleArea && currentMode === SetCoordinatesMode.limit) {
+    sizeRestrictions = __assign(__assign({}, sizeRestrictions), { minWidth: Math.min(state.visibleArea.width, sizeRestrictions.minWidth), minHeight: Math.min(state.visibleArea.height, sizeRestrictions.minHeight), maxWidth: Math.min(state.visibleArea.width, sizeRestrictions.maxWidth), maxHeight: Math.min(state.visibleArea.height, sizeRestrictions.maxHeight) });
+  }
+  var positionRestrictions = getPositionRestrictions(state, settings);
+  if (state.visibleArea && currentMode === SetCoordinatesMode.limit) {
+    positionRestrictions = mergePositionRestrictions(positionRestrictions, coordinatesToPositionRestrictions(state.visibleArea));
+  }
+  var move = function(prevCoordinates, newCoordinates) {
+    return moveCoordinatesAlgorithm(prevCoordinates, {
+      left: newCoordinates.left - (prevCoordinates.left || 0),
+      top: newCoordinates.top - (prevCoordinates.top || 0)
+    }, positionRestrictions);
+  };
+  var resize = function(prevCoordinates, newCoordinates) {
+    var coordinates2 = __assign(__assign(__assign({}, prevCoordinates), approximateSize({
+      width: newCoordinates.width,
+      height: newCoordinates.height,
+      sizeRestrictions,
+      aspectRatio
+    })), { left: 0, top: 0 });
+    return move(coordinates2, {
+      left: prevCoordinates.left || 0,
+      top: prevCoordinates.top || 0
+    });
+  };
+  var coordinates = state.coordinates ? __assign({}, state.coordinates) : emptyCoordinates();
+  var transforms = Array.isArray(transform) ? transform : [transform];
+  transforms.forEach(function(transform2) {
+    var changes;
+    if (typeof transform2 === "function") {
+      changes = transform2(__assign(__assign({}, state), { coordinates }), settings);
+    } else {
+      changes = transform2;
+    }
+    if (changes) {
+      if (!isUndefined(changes.width) || !isUndefined(changes.height)) {
+        coordinates = resize(coordinates, __assign(__assign({}, coordinates), changes));
+      }
+      if (!isUndefined(changes.left) || !isUndefined(changes.top)) {
+        coordinates = move(coordinates, __assign(__assign({}, coordinates), changes));
+      }
+    }
+  });
+  var result = __assign(__assign({}, copyState(state)), { coordinates });
+  if (result.visibleArea && currentMode === SetCoordinatesMode.zoom) {
+    var widthIntersections = Math.max(0, result.coordinates.width - result.visibleArea.width);
+    var heightIntersections = Math.max(0, result.coordinates.height - result.visibleArea.height);
+    var areaSizeRestrictions = getAreaSizeRestrictions(state, settings);
+    var scale = widthIntersections > heightIntersections ? result.coordinates.width / result.visibleArea.width : result.coordinates.height / result.visibleArea.height;
+    if (scale > 1) {
+      result.visibleArea = applyScale(result.visibleArea, Math.min(scale, maxScale(result.visibleArea, areaSizeRestrictions)));
+    }
+    result.visibleArea = applyMove(result.visibleArea, inverseMove(fitToPositionRestrictions(result.coordinates, coordinatesToPositionRestrictions(result.visibleArea))));
+    return fitVisibleArea(result, settings);
+  } else {
+    return result;
+  }
+}
+export {
+  SetCoordinatesMode,
+  setCoordinates
+};

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

@@ -0,0 +1,18 @@
+import { __assign } from "../../../../tslib@2.8.1/node_modules/tslib/tslib.es6.js";
+import { copyState } from "./copyState.js";
+import { fitCoordinates } from "../service/fitCoordinates.js";
+import { fitVisibleArea } from "../service/fitVisibleArea.js";
+function setVisibleArea(state, settings, visibleArea, safe) {
+  if (safe === void 0) {
+    safe = true;
+  }
+  var result = __assign(__assign({}, copyState(state)), { visibleArea });
+  result = fitVisibleArea(result, settings);
+  if (safe) {
+    result = fitCoordinates(result, settings);
+  }
+  return result;
+}
+export {
+  setVisibleArea
+};

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

@@ -0,0 +1,18 @@
+import { rotateImageAlgorithm } from "../algorithms/rotateImageAlgorithm.js";
+import { flipImageAlgorithm } from "../algorithms/flipImageAlgorithm.js";
+import { transformImageAlgorithm } from "../algorithms/transformImageAlgorithm.js";
+function transformImage(state, settings, transform) {
+  if (transform.rotate) {
+    state = rotateImageAlgorithm(state, settings, transform.rotate);
+  }
+  if (transform.flip) {
+    state = flipImageAlgorithm(state, settings, transform.flip.horizontal, transform.flip.vertical);
+  }
+  if (transform.move || transform.scale) {
+    state = transformImageAlgorithm(state, settings, transform);
+  }
+  return state;
+}
+export {
+  transformImage
+};

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

@@ -0,0 +1,16 @@
+var ImageRestriction;
+(function(ImageRestriction2) {
+  ImageRestriction2["fillArea"] = "fillArea";
+  ImageRestriction2["fitArea"] = "fitArea";
+  ImageRestriction2["stencil"] = "stencil";
+  ImageRestriction2["none"] = "none";
+})(ImageRestriction || (ImageRestriction = {}));
+var Priority;
+(function(Priority2) {
+  Priority2["coordinates"] = "coordinates";
+  Priority2["visibleArea"] = "visibleArea";
+})(Priority || (Priority = {}));
+export {
+  ImageRestriction,
+  Priority
+};

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

@@ -0,0 +1,268 @@
+function getDirectionNames(hDirection, vDirection) {
+  var camelCase, snakeCase;
+  if (hDirection && vDirection) {
+    camelCase = "" + hDirection + vDirection[0].toUpperCase() + vDirection.slice(1);
+    snakeCase = hDirection + "-" + vDirection;
+  } else {
+    camelCase = hDirection || vDirection;
+    snakeCase = hDirection || vDirection;
+  }
+  return { camelCase, snakeCase };
+}
+function isBlob(url) {
+  return /^blob:/.test(url);
+}
+function isDataUrl(url) {
+  return /^data:/.test(url);
+}
+function isLocal(url) {
+  return isBlob(url) || isDataUrl(url);
+}
+function isCrossOriginURL(url) {
+  if (isLocal(url)) {
+    return false;
+  }
+  var pageLocation = window.location;
+  var URL_HOST_PATTERN = /(\w+:)?(?:\/\/)([\w.-]+)?(?::(\d+))?\/?/;
+  var urlMatch = URL_HOST_PATTERN.exec(url) || [];
+  var urlparts = {
+    protocol: urlMatch[1] || "",
+    host: urlMatch[2] || "",
+    port: urlMatch[3] || ""
+  };
+  var defaultPort = function(protocol) {
+    if (protocol === "http") {
+      return 80;
+    } else {
+      return 433;
+    }
+  };
+  var portOf = function(location) {
+    return location.port || defaultPort(location.protocol || pageLocation.protocol);
+  };
+  return !(!urlparts.protocol && !urlparts.host && !urlparts.port || Boolean(urlparts.protocol && urlparts.protocol == pageLocation.protocol && urlparts.host && urlparts.host == pageLocation.host && urlparts.host && portOf(urlparts) == portOf(pageLocation)));
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isUndefined(obj) {
+  return obj === void 0;
+}
+var isObject = function(term) {
+  return term !== null && typeof term === "object";
+};
+function getOptions(options, defaultScheme, falseScheme) {
+  if (falseScheme === void 0) {
+    falseScheme = {};
+  }
+  var result = {};
+  if (isObject(options)) {
+    Object.keys(defaultScheme).forEach(function(key) {
+      if (isUndefined(options[key])) {
+        result[key] = defaultScheme[key];
+      } else if (isObject(defaultScheme[key])) {
+        if (isObject(options[key])) {
+          result[key] = getOptions(options[key], defaultScheme[key], falseScheme[key]);
+        } else {
+          result[key] = options[key] ? defaultScheme[key] : falseScheme[key];
+        }
+      } else if (defaultScheme[key] === true || defaultScheme[key] === false) {
+        result[key] = Boolean(options[key]);
+      } else {
+        result[key] = options[key];
+      }
+    });
+    return result;
+  } else {
+    if (options) {
+      return defaultScheme;
+    } else {
+      return falseScheme;
+    }
+  }
+}
+function parseNumber(number) {
+  var parsedNumber = Number(number);
+  if (Number.isNaN(parsedNumber)) {
+    return number;
+  } else {
+    return parsedNumber;
+  }
+}
+function isBoolean(value) {
+  return value === true || value === false;
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNaN(value) {
+  return value !== value;
+}
+function isNumeric(value) {
+  return isNumber(value) && !isNaN(value) || isString(value) && !Number.isNaN(parseFloat(value)) && isFinite(parseFloat(value));
+}
+function distance(firstPoint, secondPoint) {
+  return Math.sqrt(Math.pow(firstPoint.left - secondPoint.left, 2) + Math.pow(firstPoint.top - secondPoint.top, 2));
+}
+function isRoughlyEqual(a, b, tolerance) {
+  if (tolerance === void 0) {
+    tolerance = 1e-3;
+  }
+  return Math.abs(b - a) < tolerance;
+}
+function isGreater(a, b, tolerance) {
+  return isRoughlyEqual(a, b, tolerance) ? false : a > b;
+}
+function isLower(a, b, tolerance) {
+  return isRoughlyEqual(a, b, tolerance) ? false : a < b;
+}
+function sign(value) {
+  var number = +value;
+  if (number === 0 || isNaN(number)) {
+    return number;
+  }
+  return number > 0 ? 1 : -1;
+}
+function promiseTimeout(timeout) {
+  return new Promise(function(resolve) {
+    setTimeout(function() {
+      resolve();
+    }, timeout);
+  });
+}
+function deepClone(obj) {
+  if (!isObject(obj)) {
+    return obj;
+  }
+  var result = {};
+  if (Array.isArray(obj)) {
+    result = obj.map(function(item) {
+      return deepClone(item);
+    });
+  } else {
+    Object.keys(obj).forEach(function(key) {
+      return result[key] = deepClone(obj[key]);
+    });
+  }
+  return result;
+}
+function deepCompare(a, b, tolerance) {
+  if (tolerance === void 0) {
+    tolerance = 1e-3;
+  }
+  if (isNumber(a) && isNumber(b) && isRoughlyEqual(a, b, tolerance))
+    return true;
+  if (a === b)
+    return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    if (a.constructor !== b.constructor)
+      return false;
+    var length_1, i = void 0;
+    if (Array.isArray(a)) {
+      length_1 = a.length;
+      if (length_1 != b.length)
+        return false;
+      for (i = length_1; i-- !== 0; )
+        if (!deepCompare(a[i], b[i], tolerance))
+          return false;
+      return true;
+    }
+    if (a.valueOf !== Object.prototype.valueOf)
+      return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString)
+      return a.toString() === b.toString();
+    var keys = Object.keys(a);
+    length_1 = keys.length;
+    if (length_1 !== Object.keys(b).length)
+      return false;
+    for (i = length_1; i-- !== 0; )
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    for (i = length_1; i-- !== 0; ) {
+      var key = keys[i];
+      if (!deepCompare(a[key], b[key], tolerance))
+        return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
+}
+function emptyCoordinates() {
+  return {
+    left: 0,
+    top: 0,
+    width: 0,
+    height: 0
+  };
+}
+function isCardinalDirection(value) {
+  return value === "west" || value === "south" || value === "north" || value === "east";
+}
+function debounce(callback, delay) {
+  var timestamp;
+  var timeout;
+  function later() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    var last = Date.now() - timestamp;
+    var delayValue = isFunction(delay) ? delay() : delay || 0;
+    if (last < delayValue && last >= 0) {
+      timeout = setTimeout(function() {
+        return later.apply(void 0, args);
+      }, delayValue - last);
+    } else {
+      callback.apply(void 0, args);
+    }
+  }
+  function result() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    timestamp = Date.now();
+    timeout = setTimeout(function() {
+      return later.apply(void 0, args);
+    }, isFunction(delay) ? delay() : delay || 0);
+  }
+  result.clear = function() {
+    clearTimeout(timeout);
+  };
+  return result;
+}
+export {
+  debounce,
+  deepClone,
+  deepCompare,
+  distance,
+  emptyCoordinates,
+  getDirectionNames,
+  getOptions,
+  isArray,
+  isBlob,
+  isBoolean,
+  isCardinalDirection,
+  isCrossOriginURL,
+  isDataUrl,
+  isFunction,
+  isGreater,
+  isLocal,
+  isLower,
+  isNaN,
+  isNumber,
+  isNumeric,
+  isObject,
+  isRoughlyEqual,
+  isString,
+  isUndefined,
+  parseNumber,
+  promiseTimeout,
+  sign
+};

package/dist/node_modules/.pnpm/classnames@2.5.1/node_modules/classnames/index.js

@@ -0,0 +1,63 @@
+import { getDefaultExportFromCjs } from "../../../../../_virtual/_commonjsHelpers.js";
+import { __module as classnames } from "../../../../../_virtual/index.js";
+/*!
+	Copyright (c) 2018 Jed Watson.
+	Licensed under the MIT License (MIT), see
+	http://jedwatson.github.io/classnames
+*/
+(function(module) {
+  (function() {
+    var hasOwn = {}.hasOwnProperty;
+    function classNames() {
+      var classes = "";
+      for (var i = 0; i < arguments.length; i++) {
+        var arg = arguments[i];
+        if (arg) {
+          classes = appendClass(classes, parseValue(arg));
+        }
+      }
+      return classes;
+    }
+    function parseValue(arg) {
+      if (typeof arg === "string" || typeof arg === "number") {
+        return arg;
+      }
+      if (typeof arg !== "object") {
+        return "";
+      }
+      if (Array.isArray(arg)) {
+        return classNames.apply(null, arg);
+      }
+      if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]")) {
+        return arg.toString();
+      }
+      var classes = "";
+      for (var key in arg) {
+        if (hasOwn.call(arg, key) && arg[key]) {
+          classes = appendClass(classes, key);
+        }
+      }
+      return classes;
+    }
+    function appendClass(value, newClass) {
+      if (!newClass) {
+        return value;
+      }
+      if (value) {
+        return value + " " + newClass;
+      }
+      return value + newClass;
+    }
+    if (module.exports) {
+      classNames.default = classNames;
+      module.exports = classNames;
+    } else {
+      window.classNames = classNames;
+    }
+  })();
+})(classnames);
+var classnamesExports = classnames.exports;
+const cn = /* @__PURE__ */ getDefaultExportFromCjs(classnamesExports);
+export {
+  cn as default
+};