zartui 3.0.1 → 3.0.3

package/es/media-picker/index.d.ts

@@ -0,0 +1,153 @@
+export declare const MediaPicker: import("../utils").WithInstall<import("vue").DefineComponent<{
+    disabled: BooleanConstructor;
+    showTitle: BooleanConstructor;
+    title: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    mediaList: {
+        type: import("vue").PropType<import("./type").Media[]>;
+        default: () => import("./type").Media[];
+    };
+    maxImageSideLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxImageFileSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxFileSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    watermarkOptions: {
+        type: ObjectConstructor;
+        default: () => null;
+    };
+    maxMediaCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxImageCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxAudioCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxVideoCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    allowTakePhoto: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    allowPickPhoto: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    allowTakeVideo: BooleanConstructor;
+    allowPickVideo: BooleanConstructor;
+    allowTakeAudio: BooleanConstructor;
+    allowPickAudio: BooleanConstructor;
+    allowPickFile: BooleanConstructor;
+    preview: import("vue").PropType<import("./type").MediaPreview>;
+    mediaPick: import("vue").PropType<import("./type").MediaPick>;
+    beforeRead: import("vue").PropType<import("./type").MediaBeforeRead>;
+    afterRead: import("vue").PropType<import("./type").MediaAfterRead>;
+    beforeDelete: import("vue").PropType<import("./type").MediaBeforeDelete>;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:mediaList" | "delete")[], "update:mediaList" | "delete", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: BooleanConstructor;
+    showTitle: BooleanConstructor;
+    title: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    mediaList: {
+        type: import("vue").PropType<import("./type").Media[]>;
+        default: () => import("./type").Media[];
+    };
+    maxImageSideLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxImageFileSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxFileSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    watermarkOptions: {
+        type: ObjectConstructor;
+        default: () => null;
+    };
+    maxMediaCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxImageCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxAudioCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxVideoCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    allowTakePhoto: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    allowPickPhoto: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    allowTakeVideo: BooleanConstructor;
+    allowPickVideo: BooleanConstructor;
+    allowTakeAudio: BooleanConstructor;
+    allowPickAudio: BooleanConstructor;
+    allowPickFile: BooleanConstructor;
+    preview: import("vue").PropType<import("./type").MediaPreview>;
+    mediaPick: import("vue").PropType<import("./type").MediaPick>;
+    beforeRead: import("vue").PropType<import("./type").MediaBeforeRead>;
+    afterRead: import("vue").PropType<import("./type").MediaAfterRead>;
+    beforeDelete: import("vue").PropType<import("./type").MediaBeforeDelete>;
+}>> & {
+    "onUpdate:mediaList"?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+}, {
+    title: string;
+    disabled: boolean;
+    showTitle: boolean;
+    mediaList: import("./type").Media[];
+    maxImageSideLength: number;
+    maxImageFileSize: number;
+    maxFileSize: number;
+    watermarkOptions: Record<string, any>;
+    maxMediaCount: number;
+    maxImageCount: number;
+    maxAudioCount: number;
+    maxVideoCount: number;
+    allowTakePhoto: boolean;
+    allowPickPhoto: boolean;
+    allowTakeVideo: boolean;
+    allowPickVideo: boolean;
+    allowTakeAudio: boolean;
+    allowPickAudio: boolean;
+    allowPickFile: boolean;
+}>>;
+export default MediaPicker;
+export type { MediaPickerProps } from './MediaPicker';
+declare module 'vue' {
+    interface GlobalComponents {
+        ZtMediaPicker: typeof MediaPicker;
+    }
+}

package/es/media-picker/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from "../utils/index.mjs";
+import _MediaPicker from "./MediaPicker.mjs";
+const MediaPicker = withInstall(_MediaPicker);
+var stdin_default = MediaPicker;
+export {
+  MediaPicker,
+  stdin_default as default
+};

package/es/media-picker/style/index.d.ts

@@ -0,0 +1 @@
+export {};

package/es/media-picker/style/index.mjs

@@ -0,0 +1,16 @@
+import "../../style/base.css";
+import "../../badge/index.css";
+import "../../icon/index.css";
+import "../../image/index.css";
+import "../../overlay/index.css";
+import "../../popup/index.css";
+import "../../media-player/index.css";
+import "../../loading/index.css";
+import "../../toast/index.css";
+import "../../action-sheet/index.css";
+import "../../swipe/index.css";
+import "../../swipe-item/index.css";
+import "../../image-preview/index.css";
+import "../../grid/index.css";
+import "../../grid-item/index.css";
+import "../index.css";

package/es/media-picker/type.d.ts

@@ -0,0 +1,22 @@
+export declare type MediaType = 'photo' | 'audio' | 'video' | 'file';
+export declare type MediaAddType = 'take' | 'pick' | 'take_and_pick';
+export declare type MediaUploadStatus = 'uploading' | 'done' | 'failed';
+export declare type Media = {
+    file: File;
+    url?: string;
+    type: MediaType;
+    uniqueCode: string;
+    showSrc?: string;
+    fileSize: number;
+    lastModified: number;
+    deletable: boolean;
+    status?: MediaUploadStatus;
+    message?: string;
+    mediaShot?: string;
+    extra?: object;
+};
+export declare type MediaBeforeRead = (files: Array<File>) => boolean | Promise<Array<File>>;
+export declare type MediaAfterRead = (medias: Array<Media>) => void;
+export declare type MediaBeforeDelete = (media: Media) => boolean | Promise<void>;
+export declare type MediaPick = (mediaType: MediaType, mediaAddType: MediaAddType) => boolean;
+export declare type MediaPreview = (medias: Array<Media>, index: number) => boolean;

package/es/media-picker/util/media-util.d.ts

@@ -0,0 +1,71 @@
+export declare const MAX_SIDE_LENGTH = 1920;
+export declare const MIN_SIDE_LENGTH = 480;
+export declare const PHOTO_FILE_SIZE_LIMIT = 1000;
+export declare function isImageType(file: File): boolean;
+export declare function isAudioType(file: File): boolean;
+export declare function isVideoType(file: File): boolean;
+/**
+ * 文件唯一标识
+ */
+export declare function getFileUniqueCode(file: File): string;
+/**
+ * 生成不重复的文件名
+ * @param {File} file 原始文件
+ * @param {string} suffix 指定文件名后缀
+ */
+export declare function getUniqueFileName(file: File, suffix?: string): string;
+/**
+ * Convert File to data schema url
+ * @param file
+ */
+export declare function file2DataURL(file: File): Promise<string>;
+/**
+ * Convert file to image
+ * @param file
+ */
+export declare function file2Image(file: File): Promise<HTMLImageElement>;
+/**
+ * Draw image on canvas
+ * @param img
+ * @param width
+ * @param height
+ */
+export declare function image2Canvas(img: HTMLImageElement, width?: number, height?: number): Promise<HTMLCanvasElement>;
+/**
+ * Export File from canvas
+ * @param canvas
+ * @param fileName
+ * @param lastModified
+ * @param type
+ * @param quality
+ * @see {@link https://meshworld.in/convert-canvas-to-an-image-using-javascript/}
+ */
+export declare function canvas2File(canvas: HTMLCanvasElement, fileName: string, lastModified: number, type?: string, quality?: number): Promise<File>;
+export declare function image2file(img: HTMLImageElement, fileName: string, lastModified: number, type?: string, quality?: number): Promise<File>;
+/**
+ * Export Image from canvas
+ * @param canvas
+ * @param type
+ * @param quality
+ * @see {@link https://meshworld.in/convert-canvas-to-an-image-using-javascript/}
+ */
+export declare function canvas2Image(canvas: HTMLCanvasElement, type?: string, quality?: number): Promise<HTMLImageElement>;
+export declare type ResizeResultType = 'image' | 'canvas';
+/**
+ * 缩放图片
+ * @param img：HTMLImageElement 图片对象
+ * @param imageWidth 图片宽度
+ * @param imageHeight 图片高度
+ // * @param equalProportion 是否等比例拉伸，默认是，目前只支持等比例拉伸
+ * @param sideLengthLimit 图片边长限制
+ * @param baseOnShortSide 是否以短边为限制
+ * @param resultType: ResizeResultType, "image" | "canvas"
+ */
+export declare function resize(img: HTMLImageElement, { imageWidth, imageHeight, sideLengthLimit, baseOnShortSide, // 是否以短边为基准缩放
+resultType, }: {
+    imageWidth?: number | undefined;
+    imageHeight?: number | undefined;
+    sideLengthLimit?: number | undefined;
+    baseOnShortSide?: boolean | undefined;
+    resultType?: string | undefined;
+}): Promise<HTMLImageElement | HTMLCanvasElement>;

package/es/media-picker/util/media-util.mjs

@@ -0,0 +1,139 @@
+const MAX_SIDE_LENGTH = 1920;
+const MIN_SIDE_LENGTH = 480;
+const PHOTO_FILE_SIZE_LIMIT = 1e3;
+function isImageType(file) {
+  return file.type.indexOf("image/") >= 0;
+}
+function isAudioType(file) {
+  return file.type.indexOf("audio/") >= 0;
+}
+function isVideoType(file) {
+  return file.type.indexOf("video/") >= 0;
+}
+function getFileUniqueCode(file) {
+  return `${file.name}_${file.type}_${file.size}_${file.lastModified}`;
+}
+function getUniqueFileName(file, suffix = "") {
+  const dotIndex = file.name.lastIndexOf(".");
+  if (dotIndex > 0) {
+    suffix = file.name.substring(dotIndex + 1);
+  }
+  const now = new Date();
+  const name = `${now.getFullYear()}${now.getMonth()}${now.getDay()}${now.getHours()}${now.getMinutes()}${now.getSeconds()}${now.getMilliseconds()}_${Math.ceil(
+    Math.random() * 1e4
+  )}`;
+  return suffix ? name + "." + suffix : name;
+}
+function file2DataURL(file) {
+  return new Promise((resolve, reject) => {
+    const a = new FileReader();
+    a.onload = function(res) {
+      if (res && res.target) {
+        resolve(res.target.result);
+      } else {
+        reject(new Error("\u8BFB\u53D6\u6587\u4EF6url\u5931\u8D25"));
+      }
+    };
+    a.readAsDataURL(file);
+  });
+}
+function file2Image(file) {
+  return new Promise((resolve, reject) => {
+    file2DataURL(file).then((url) => {
+      const img = new Image();
+      img.src = url;
+      img.onload = function() {
+        if (img.complete) {
+          resolve(img);
+        } else {
+          reject(new Error("\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25"));
+        }
+      };
+    }).catch(reject);
+  });
+}
+function image2Canvas(img, width, height) {
+  const canvas = document.createElement("canvas");
+  const _width = width || img.width;
+  const _height = height || img.height;
+  canvas.width = _width;
+  canvas.height = _height;
+  const ctx = canvas.getContext("2d");
+  if (ctx) {
+    ctx.fillStyle = "#fff";
+    ctx.fillRect(0, 0, _width, _height);
+    ctx.drawImage(img, 0, 0, _width, _height);
+    return Promise.resolve(canvas);
+  }
+  return Promise.reject(new Error("canvas getContext return null"));
+}
+function canvas2File(canvas, fileName, lastModified, type = "image/jpeg", quality = 0.8) {
+  return new Promise((resolve, reject) => {
+    canvas.toBlob(
+      (blob) => {
+        if (!blob) {
+          reject(new Error("canvas\u6587\u4EF6\u5BFC\u51FA\u5931\u8D25"));
+        } else {
+          const file = new File([blob], fileName, { lastModified, type });
+          resolve(file);
+        }
+      },
+      type,
+      quality
+    );
+  });
+}
+function image2file(img, fileName, lastModified, type = "image/jpeg", quality = 0.8) {
+  return image2Canvas(img).then(
+    (canvas) => canvas2File(canvas, fileName, lastModified, type, quality)
+  );
+}
+function canvas2Image(canvas, type = "image/jpeg", quality = 0.8) {
+  const image = new Image();
+  image.src = canvas.toDataURL(type, quality);
+  return Promise.resolve(image);
+}
+function resize(img, {
+  imageWidth = -1,
+  imageHeight = -1,
+  sideLengthLimit = 640,
+  baseOnShortSide = true,
+  resultType = "image"
+}) {
+  let scale = 1;
+  const scaleBaseFunc = baseOnShortSide ? Math.min : Math.max;
+  if (imageWidth > 0 && imageHeight > 0) {
+    scale = sideLengthLimit / scaleBaseFunc(imageWidth, imageHeight);
+  } else if (img.width > 0 && img.height > 0) {
+    scale = sideLengthLimit / scaleBaseFunc(img.width, img.height);
+    imageWidth = img.width;
+    imageHeight = img.height;
+  } else {
+    return Promise.reject(new Error("image width/height \u65E0\u6548"));
+  }
+  const targetWidth = imageWidth * scale;
+  const targetHeight = imageHeight * scale;
+  if (resultType === "image") {
+    return image2Canvas(img, targetWidth, targetHeight).then(
+      (canvas) => canvas2Image(canvas)
+    );
+  }
+  return image2Canvas(img, targetWidth, targetHeight);
+}
+export {
+  MAX_SIDE_LENGTH,
+  MIN_SIDE_LENGTH,
+  PHOTO_FILE_SIZE_LIMIT,
+  canvas2File,
+  canvas2Image,
+  file2DataURL,
+  file2Image,
+  getFileUniqueCode,
+  getUniqueFileName,
+  image2Canvas,
+  image2file,
+  isAudioType,
+  isImageType,
+  isVideoType,
+  resize
+};

package/es/media-picker/util/orientation-util.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Get string from char code in data view.
+ * @param {DataView} dataView - The data view for read.
+ * @param {number} start - The start index.
+ * @param {number} length - The read length.
+ * @returns {string} The read result.
+ */
+export declare function getStringFromCharCode(dataView: DataView, start: number, length: number): string;
+/**
+ * Get orientation value from given array buffer.
+ * @param {ArrayBuffer} arrayBuffer - The array buffer to read.
+ * @returns {number} The read orientation value.
+ */
+export declare function resetAndGetOrientation(arrayBuffer: ArrayBufferLike): number;
+/**
+ * Convert array-like or iterable object to an array.
+ * @param {*} value - The value to convert.
+ * @returns {Array} Returns a new array.
+ */
+export declare function toArray(value: ArrayLike<unknown>): any[];
+/**
+ * Transform array buffer to Data URL.
+ * @param {ArrayBuffer} arrayBuffer - The array buffer to transform.
+ * @param {string} mimeType - The mime type of the Data URL.
+ * @returns {string} The result Data URL.
+ */
+export declare function arrayBufferToDataURL(arrayBuffer: ArrayBuffer, mimeType: string): string;
+/**
+ * Parse Exif Orientation value.
+ * @param {number} orientation - The orientation to parse.
+ * @returns {Object} The parsed result.
+ */
+export declare function parseOrientation(orientation: number): {
+    rotate: number;
+    scaleX: number;
+    scaleY: number;
+};

package/es/media-picker/util/orientation-util.mjs

@@ -0,0 +1,118 @@
+function getStringFromCharCode(dataView, start, length) {
+  let str = "";
+  let i;
+  length += start;
+  for (i = start; i < length; i += 1) {
+    str += String.fromCharCode(dataView.getUint8(i));
+  }
+  return str;
+}
+function resetAndGetOrientation(arrayBuffer) {
+  const dataView = new DataView(arrayBuffer);
+  let orientation = 0;
+  try {
+    let littleEndian;
+    let app1Start;
+    let ifdStart;
+    if (dataView.getUint8(0) === 255 && dataView.getUint8(1) === 216) {
+      const length = dataView.byteLength;
+      let offset = 2;
+      while (offset + 1 < length) {
+        if (dataView.getUint8(offset) === 255 && dataView.getUint8(offset + 1) === 225) {
+          app1Start = offset;
+          break;
+        }
+        offset += 1;
+      }
+    }
+    if (app1Start) {
+      const exifIDCode = app1Start + 4;
+      const tiffOffset = app1Start + 10;
+      if (getStringFromCharCode(dataView, exifIDCode, 4) === "Exif") {
+        const endianness = dataView.getUint16(tiffOffset);
+        littleEndian = endianness === 18761;
+        if (littleEndian || endianness === 19789) {
+          if (dataView.getUint16(tiffOffset + 2, littleEndian) === 42) {
+            const firstIFDOffset = dataView.getUint32(tiffOffset + 4, littleEndian);
+            if (firstIFDOffset >= 8) {
+              ifdStart = tiffOffset + firstIFDOffset;
+            }
+          }
+        }
+      }
+    }
+    if (ifdStart) {
+      const length = dataView.getUint16(ifdStart, littleEndian);
+      let offset;
+      let i;
+      for (i = 0; i < length; i += 1) {
+        offset = ifdStart + i * 12 + 2;
+        if (dataView.getUint16(offset, littleEndian) === 274) {
+          offset += 8;
+          orientation = dataView.getUint16(offset, littleEndian);
+          dataView.setUint16(offset, 1, littleEndian);
+          break;
+        }
+      }
+    }
+  } catch (e) {
+    orientation = 1;
+  }
+  return orientation;
+}
+function toArray(value) {
+  return Array.from ? Array.from(value) : Array.prototype.slice.call(value);
+}
+function arrayBufferToDataURL(arrayBuffer, mimeType) {
+  const chunks = [];
+  const chunkSize = 8192;
+  let uint8 = new Uint8Array(arrayBuffer);
+  while (uint8.length > 0) {
+    chunks.push(String.fromCharCode.apply(null, toArray(uint8.subarray(0, chunkSize))));
+    uint8 = uint8.subarray(chunkSize);
+  }
+  return `data:${mimeType};base64,${btoa(chunks.join(""))}`;
+}
+function parseOrientation(orientation) {
+  let rotate = 0;
+  let scaleX = 1;
+  let scaleY = 1;
+  switch (orientation) {
+    case 2:
+      scaleX = -1;
+      break;
+    case 3:
+      rotate = -180;
+      break;
+    case 4:
+      scaleY = -1;
+      break;
+    case 5:
+      rotate = 90;
+      scaleY = -1;
+      break;
+    case 6:
+      rotate = 90;
+      break;
+    case 7:
+      rotate = 90;
+      scaleX = -1;
+      break;
+    case 8:
+      rotate = -90;
+      break;
+    default:
+  }
+  return {
+    rotate,
+    scaleX,
+    scaleY
+  };
+}
+export {
+  arrayBufferToDataURL,
+  getStringFromCharCode,
+  parseOrientation,
+  resetAndGetOrientation,
+  toArray
+};

package/es/media-picker/watermark/compress-options.d.ts

@@ -0,0 +1,5 @@
+export declare class CompressOptions {
+    photoFileSizeLimit: number;
+    checkOrientation: boolean;
+    constructor(photoFileSizeLimit: number);
+}

package/es/media-picker/watermark/compress-options.mjs

@@ -0,0 +1,15 @@
+import { isDef } from "../../utils/index.mjs";
+import { PHOTO_FILE_SIZE_LIMIT } from "../util/media-util.mjs";
+class CompressOptions {
+  constructor(photoFileSizeLimit) {
+    this.checkOrientation = true;
+    if (!isDef(photoFileSizeLimit)) {
+      this.photoFileSizeLimit = PHOTO_FILE_SIZE_LIMIT;
+    } else {
+      this.photoFileSizeLimit = photoFileSizeLimit;
+    }
+  }
+}
+export {
+  CompressOptions
+};

package/es/media-picker/watermark/image-processor.d.ts

@@ -0,0 +1,12 @@
+import { ResizeOptions } from './resize-options';
+import { WatermarkOptions } from './watermark';
+import { CompressOptions } from './compress-options';
+export declare class ImageProcessor {
+    private file;
+    private resizeOptions;
+    private watermarkOptions;
+    private compressOptions;
+    constructor(file: File, resizeOptions: ResizeOptions, watermarkOptions: WatermarkOptions, compressOptions: CompressOptions);
+    process(): Promise<void | File>;
+    compress(canvas: HTMLCanvasElement, filename: string, lastModified: number, type: string, quality: number): Promise<File>;
+}

package/es/media-picker/watermark/image-processor.mjs

@@ -0,0 +1,55 @@
+import { renderWatermark } from "./watermark.mjs";
+import { canvas2File, file2Image, resize } from "../util/media-util.mjs";
+const DEFAULT_IMAGE_TYPE = "image/jpeg";
+const DEFAULT_JPEG_QUALITY = 0.8;
+const MIN_JPEG_QUALITY = 0.1;
+const JPEG_QUALITY_STEP = 0.05;
+class ImageProcessor {
+  constructor(file, resizeOptions, watermarkOptions, compressOptions) {
+    this.file = file;
+    this.resizeOptions = resizeOptions;
+    this.watermarkOptions = watermarkOptions;
+    this.compressOptions = compressOptions;
+  }
+  process() {
+    const filename = this.file.name;
+    const { lastModified } = this.file;
+    return file2Image(this.file).then(
+      (img) => resize(img, {
+        sideLengthLimit: this.resizeOptions.maxSideLength,
+        resultType: "canvas"
+      })
+    ).then((result) => {
+      const canvas = result;
+      return renderWatermark(canvas, this.watermarkOptions);
+    }).then((canvas) => {
+      const exportFilename = filename.replace(/\./g, "-") + ".jpg";
+      return this.compress(
+        canvas,
+        exportFilename,
+        lastModified,
+        DEFAULT_IMAGE_TYPE,
+        DEFAULT_JPEG_QUALITY
+      );
+    });
+  }
+  compress(canvas, filename, lastModified, type, quality) {
+    return canvas2File(canvas, filename, lastModified, type, quality).then(
+      (file) => {
+        if (file.size > this.compressOptions.photoFileSizeLimit * 1024 && quality - JPEG_QUALITY_STEP > MIN_JPEG_QUALITY) {
+          return this.compress(
+            canvas,
+            filename,
+            lastModified,
+            type,
+            quality - JPEG_QUALITY_STEP
+          );
+        }
+        return Promise.resolve(file);
+      }
+    );
+  }
+}
+export {
+  ImageProcessor
+};

package/es/media-picker/watermark/resize-options.d.ts

@@ -0,0 +1,4 @@
+export declare class ResizeOptions {
+    maxSideLength: number;
+    constructor(maxSideLength: number);
+}

package/es/media-picker/watermark/resize-options.mjs

@@ -0,0 +1,19 @@
+import { isDef } from "../../utils/index.mjs";
+import { MAX_SIDE_LENGTH, MIN_SIDE_LENGTH } from "../util/media-util.mjs";
+class ResizeOptions {
+  constructor(maxSideLength) {
+    if (!isDef(maxSideLength)) {
+      this.maxSideLength = MAX_SIDE_LENGTH;
+    } else {
+      this.maxSideLength = maxSideLength;
+      if (this.maxSideLength > MAX_SIDE_LENGTH) {
+        this.maxSideLength = MAX_SIDE_LENGTH;
+      } else if (this.maxSideLength < MIN_SIDE_LENGTH) {
+        this.maxSideLength = MIN_SIDE_LENGTH;
+      }
+    }
+  }
+}
+export {
+  ResizeOptions
+};