@streamscloud/kit 0.63.0 → 0.64.0

package/dist/ui/cropper/img-cropper/frame-geometry.d.ts

@@ -0,0 +1,82 @@
+export type Size = {
+    w: number;
+    h: number;
+};
+export type Point = {
+    x: number;
+    y: number;
+};
+export type Rect = Point & Size;
+export type FrameFitMode = 'cover' | 'contain';
+/** The frame the rect is being fitted into, the aspect it must keep, and the mode's placement rule. */
+export type FrameContext = {
+    frame: Size;
+    aspect: number;
+    mode: FrameFitMode;
+    free?: boolean;
+};
+export declare const MAX_FRAME_ZOOM = 5;
+export declare const MIN_FREE_ZOOM = 0.1;
+/** Smallest `aspect`-shaped rect that fully covers `frame`, centered. */
+export declare const coverBox: (frame: Size, aspect: number) => Rect;
+/** Largest `aspect`-shaped rect that fits inside `frame`, centered. */
+export declare const containBox: (frame: Size, aspect: number) => Rect;
+/** Zoom relative to the cover size: 1 means the rect exactly covers the frame. */
+export declare const zoomOf: (rect: Size, frame: Size, aspect: number) => number;
+/** The zoom at which a rect exactly fits inside the frame — at or below 1. */
+export declare const containZoom: (frame: Size, aspect: number) => number;
+/**
+ * Constrains a rect's size to the mode's floor/ceiling and its position so it never violates the mode's placement
+ * rule (always covering the frame in `cover`, always inside it in `contain`) unless `free` lifts the position rule.
+ */
+export declare const clampBox: (rect: Rect, ctx: FrameContext) => Rect;
+/**
+ * Scales a rect by `factor` about a frame-local anchor point, capping the factor to the floor/ceiling first.
+ * When the anchor is the rect's own corner (handle drag) and the scale hits a position limit, `clampPosition` still
+ * slides the rect and the opposite corner drifts — deliberate: a hard stop there felt worse.
+ */
+export declare const scaleBox: (rect: Rect, factor: number, anchor: Point, ctx: FrameContext) => Rect;
+/**
+ * The box after the frame and the picture turn a quarter together about the frame's center, so whatever was inside
+ * the frame stays inside, just turned. `from` is the frame before the turn (its width and height swap in the turn);
+ * `ctx.frame` is the frame after it, laid out anew, so everything is scaled by how much the turned frame resized.
+ * Only meaningful when the frame follows the picture's own aspect — a fixed-aspect frame can't turn.
+ *
+ * Screen y grows downward, so a clockwise turn maps an offset `(dx, dy)` from the center to `(-dy, dx)`.
+ */
+export declare const boxTurnedWithFrame: ({ box, from, clockwise, ctx }: {
+    box: Rect;
+    from: Size;
+    clockwise: boolean;
+    ctx: FrameContext;
+}) => Rect;
+/** Rescales a rect to an absolute `zoom` (relative to cover), about the frame's center. */
+export declare const boxAtZoom: (rect: Rect, zoom: number, ctx: FrameContext) => Rect;
+/** Moves a rect by a frame-local delta, then re-clamps it. */
+export declare const moveBox: (rect: Rect, delta: Point, ctx: FrameContext) => Rect;
+/**
+ * Snaps a rect so its `fx`/`fy` fraction (0, 0.5 or 1 along each axis) lines up with the same fraction of the frame.
+ * Works for both regimes: for a bigger rect `frame - size` is negative, so 0 aligns starts, 1 aligns ends.
+ */
+export declare const alignBox: (rect: Rect, fx: number, fy: number, ctx: FrameContext) => Rect;
+/** Largest `aspect`-shaped rect that fits `available`, centered — how the frame itself is laid out on the stage. */
+export declare const fitFrame: (available: Size, aspect: number) => Rect;
+/** Moves a selection rect by a frame-local delta, keeping it fully inside `frame`. */
+export declare const shiftSelection: ({ rect, delta, frame }: {
+    rect: Rect;
+    delta: Point;
+    frame: Size;
+}) => Rect;
+/**
+ * A drag-constructed selection inside `frame`, anchored at `anchor` and growing toward `point` — locked to `aspect` when
+ * given, free-form when `aspect` is null. `anchor` never moves; growth stops at the frame edge instead of wrapping the
+ * anchor past it, and at `minSize` on the shorter side instead of shrinking further. The caller passes `minSize` once the
+ * selection is valid, so it can't become invalid again; one still growing from zero passes none.
+ */
+export declare const selectionFromDrag: ({ anchor, point, frame, aspect, minSize }: {
+    anchor: Point;
+    point: Point;
+    frame: Size;
+    aspect: number | null;
+    minSize?: number;
+}) => Rect;

package/dist/ui/cropper/img-cropper/frame-geometry.js

@@ -0,0 +1,165 @@
+/*
+ * Pure geometry behind `ImgCropper`. All rects are frame-local: (0, 0) is the frame's top-left corner. The picture's
+ * box routinely extends past `[0, frame.w] × [0, frame.h]` (that spill is the dimmed part); a selection never does.
+ * Zoom is measured against `coverBox`: 1 = the picture exactly covers the frame, contain-fit is ≤ 1.
+ * Sizes are driven by width, height is derived (`h = w / aspect`), so the aspect can't drift through rounding.
+ */
+export const MAX_FRAME_ZOOM = 5;
+export const MIN_FREE_ZOOM = 0.1;
+const MIN_FREE_OVERLAP_PX = 24;
+const round2 = (value) => Math.round(value * 100) / 100;
+/** Smallest `aspect`-shaped rect that fully covers `frame`, centered. */
+export const coverBox = (frame, aspect) => {
+    const byWidth = { w: frame.w, h: frame.w / aspect };
+    const byHeight = { w: frame.h * aspect, h: frame.h };
+    const { w, h } = byWidth.h >= frame.h ? byWidth : byHeight;
+    return { x: (frame.w - w) / 2, y: (frame.h - h) / 2, w, h };
+};
+/** Largest `aspect`-shaped rect that fits inside `frame`, centered. */
+export const containBox = (frame, aspect) => {
+    const byWidth = { w: frame.w, h: frame.w / aspect };
+    const byHeight = { w: frame.h * aspect, h: frame.h };
+    const { w, h } = byWidth.h <= frame.h ? byWidth : byHeight;
+    return { x: (frame.w - w) / 2, y: (frame.h - h) / 2, w, h };
+};
+/** Zoom relative to the cover size: 1 means the rect exactly covers the frame. */
+export const zoomOf = (rect, frame, aspect) => rect.w / coverBox(frame, aspect).w;
+/** The zoom at which a rect exactly fits inside the frame — at or below 1. */
+export const containZoom = (frame, aspect) => containBox(frame, aspect).w / coverBox(frame, aspect).w;
+/** Size floor: `free` allows almost anything; otherwise `contain` stops at fitting inside (gaps allowed), `cover` at exactly covering. */
+const minWidth = (ctx) => {
+    const { frame, aspect, mode, free } = ctx;
+    const cover = coverBox(frame, aspect);
+    if (free) {
+        return cover.w * MIN_FREE_ZOOM;
+    }
+    return mode === 'contain' ? containBox(frame, aspect).w : cover.w;
+};
+/**
+ * Constrained position on one axis so the rect never opens a gap past the frame's edge on that side.
+ * One formula for both regimes — `frameSize - size` flips sign between them:
+ * - rect bigger than the frame: range `[frameSize - size, 0]`, so it always covers the frame;
+ * - rect smaller than the frame: range `[0, frameSize - size]`, so it stays fully inside.
+ */
+const clampAxisBounded = (position, size, frameSize) => {
+    const minPosition = Math.min(0, frameSize - size);
+    const maxPosition = Math.max(0, frameSize - size);
+    return Math.min(Math.max(position, minPosition), maxPosition);
+};
+/** Free mode: the rect may leave the frame, but at least `overlap` of it stays over the frame on either side. */
+const clampAxisFree = (position, size, frameSize) => {
+    const overlap = Math.min(MIN_FREE_OVERLAP_PX, size, frameSize);
+    return Math.min(Math.max(position, overlap - size), frameSize - overlap);
+};
+const clampSize = (rect, ctx) => {
+    const w = round2(Math.min(Math.max(rect.w, minWidth(ctx)), coverBox(ctx.frame, ctx.aspect).w * MAX_FRAME_ZOOM));
+    return { ...rect, w, h: round2(w / ctx.aspect) };
+};
+const clampPosition = (rect, ctx) => {
+    const clampAxis = ctx.free ? clampAxisFree : clampAxisBounded;
+    return { ...rect, x: round2(clampAxis(rect.x, rect.w, ctx.frame.w)), y: round2(clampAxis(rect.y, rect.h, ctx.frame.h)) };
+};
+/**
+ * Constrains a rect's size to the mode's floor/ceiling and its position so it never violates the mode's placement
+ * rule (always covering the frame in `cover`, always inside it in `contain`) unless `free` lifts the position rule.
+ */
+export const clampBox = (rect, ctx) => clampPosition(clampSize(rect, ctx), ctx);
+/**
+ * Scales a rect by `factor` about a frame-local anchor point, capping the factor to the floor/ceiling first.
+ * When the anchor is the rect's own corner (handle drag) and the scale hits a position limit, `clampPosition` still
+ * slides the rect and the opposite corner drifts — deliberate: a hard stop there felt worse.
+ */
+// Capping size after applying the raw factor to position (instead of capping the factor itself) drifts the anchor
+// a little further every repeated call sitting at the floor/ceiling — position and size go out of sync.
+export const scaleBox = (rect, factor, anchor, ctx) => {
+    const targetWidth = clampSize({ ...rect, w: rect.w * factor }, ctx).w;
+    const appliedFactor = targetWidth / rect.w;
+    const scaled = {
+        x: anchor.x + (rect.x - anchor.x) * appliedFactor,
+        y: anchor.y + (rect.y - anchor.y) * appliedFactor,
+        w: targetWidth,
+        h: targetWidth / ctx.aspect
+    };
+    return clampPosition(scaled, ctx);
+};
+/**
+ * The box after the frame and the picture turn a quarter together about the frame's center, so whatever was inside
+ * the frame stays inside, just turned. `from` is the frame before the turn (its width and height swap in the turn);
+ * `ctx.frame` is the frame after it, laid out anew, so everything is scaled by how much the turned frame resized.
+ * Only meaningful when the frame follows the picture's own aspect — a fixed-aspect frame can't turn.
+ *
+ * Screen y grows downward, so a clockwise turn maps an offset `(dx, dy)` from the center to `(-dy, dx)`.
+ */
+export const boxTurnedWithFrame = ({ box, from, clockwise, ctx }) => {
+    const dx = box.x + box.w / 2 - from.w / 2;
+    const dy = box.y + box.h / 2 - from.h / 2;
+    const turned = clockwise ? { x: -dy, y: dx } : { x: dy, y: -dx };
+    const scale = ctx.frame.w / from.h;
+    const w = box.h * scale;
+    const h = box.w * scale;
+    const center = { x: ctx.frame.w / 2 + turned.x * scale, y: ctx.frame.h / 2 + turned.y * scale };
+    return clampBox({ x: center.x - w / 2, y: center.y - h / 2, w, h }, ctx);
+};
+/** Rescales a rect to an absolute `zoom` (relative to cover), about the frame's center. */
+export const boxAtZoom = (rect, zoom, ctx) => {
+    const targetWidth = coverBox(ctx.frame, ctx.aspect).w * zoom;
+    const center = { x: ctx.frame.w / 2, y: ctx.frame.h / 2 };
+    return scaleBox(rect, targetWidth / rect.w, center, ctx);
+};
+/** Moves a rect by a frame-local delta, then re-clamps it. */
+export const moveBox = (rect, delta, ctx) => clampBox({ ...rect, x: rect.x + delta.x, y: rect.y + delta.y }, ctx);
+/**
+ * Snaps a rect so its `fx`/`fy` fraction (0, 0.5 or 1 along each axis) lines up with the same fraction of the frame.
+ * Works for both regimes: for a bigger rect `frame - size` is negative, so 0 aligns starts, 1 aligns ends.
+ */
+export const alignBox = (rect, fx, fy, ctx) => clampBox({ ...rect, x: fx * (ctx.frame.w - rect.w), y: fy * (ctx.frame.h - rect.h) }, ctx);
+/** Largest `aspect`-shaped rect that fits `available`, centered — how the frame itself is laid out on the stage. */
+export const fitFrame = (available, aspect) => containBox(available, aspect);
+/** Moves a selection rect by a frame-local delta, keeping it fully inside `frame`. */
+export const shiftSelection = ({ rect, delta, frame }) => ({
+    ...rect,
+    x: round2(clampAxisBounded(rect.x + delta.x, rect.w, frame.w)),
+    y: round2(clampAxisBounded(rect.y + delta.y, rect.h, frame.h))
+});
+/**
+ * Grows toward the pointer unless `minSize` doesn't fit that side of `anchor` — then stays on the other side.
+ * Only bites on a resize dragged across the anchor toward a near edge; the original side always has room, since the
+ * selection already fit there at the minimum.
+ */
+const growsPositive = (towardPositive, anchor, frameSize, minSize) => towardPositive ? frameSize - anchor >= minSize : anchor < minSize;
+/**
+ * A drag-constructed selection inside `frame`, anchored at `anchor` and growing toward `point` — locked to `aspect` when
+ * given, free-form when `aspect` is null. `anchor` never moves; growth stops at the frame edge instead of wrapping the
+ * anchor past it, and at `minSize` on the shorter side instead of shrinking further. The caller passes `minSize` once the
+ * selection is valid, so it can't become invalid again; one still growing from zero passes none.
+ */
+export const selectionFromDrag = ({ anchor, point, frame, aspect, minSize = 0 }) => {
+    // The minimum is for the shorter side: a wide aspect has the shorter height, so its width floor is min × aspect.
+    const minW = aspect === null ? minSize : minSize * Math.max(1, aspect);
+    const minH = aspect === null ? minSize : minW / aspect;
+    const growRight = growsPositive(point.x >= anchor.x, anchor.x, frame.w, minW);
+    const growDown = growsPositive(point.y >= anchor.y, anchor.y, frame.h, minH);
+    const roomX = growRight ? frame.w - anchor.x : anchor.x;
+    const roomY = growDown ? frame.h - anchor.y : anchor.y;
+    const dx = Math.max(Math.min(Math.abs(point.x - anchor.x), roomX), minW);
+    const dy = Math.max(Math.min(Math.abs(point.y - anchor.y), roomY), minH);
+    let w;
+    let h;
+    if (aspect === null) {
+        w = dx;
+        h = dy;
+    }
+    else {
+        // The two axes imply different sizes; take the larger so the selection keeps up with the drag (deliberate), then
+        // cap by both rooms — the larger candidate can overshoot the other axis.
+        const candidateW = dx / aspect < dy ? dy * aspect : dx;
+        w = Math.min(candidateW, roomX, roomY * aspect);
+        h = round2(w / aspect);
+    }
+    return {
+        x: round2(growRight ? anchor.x : anchor.x - w),
+        y: round2(growDown ? anchor.y : anchor.y - h),
+        w: round2(w),
+        h
+    };
+};

package/dist/ui/cropper/img-cropper/img-cropper-localization.d.ts

@@ -1,6 +1,5 @@
 export declare class ImgCropperLocalization {
-    get apply(): string;
-    get cancel(): string;
     get imageLoadError(): string;
-    get initCropperError(): string;
+    get resizeHandle(): string;
+    get resizeSelection(): string;
 }

package/dist/ui/cropper/img-cropper/img-cropper-localization.js

@@ -1,33 +1,26 @@
 import { AppLocale } from '../../../core/locale';
 const loc = {
-    apply: {
-        en: 'Apply',
-        no: 'Bruk'
-    },
-    cancel: {
-        en: 'Cancel',
-        no: 'Avbryt'
-    },
     imageLoadError: {
         en: 'Failed to load image',
         no: 'Kunne ikke laste bildet'
     },
-    initCropperError: {
-        en: 'Failed to initialize cropper',
-        no: 'Kunne ikke initialisere cropper'
+    resizeHandle: {
+        en: 'Resize picture',
+        no: 'Endre størrelse på bildet'
+    },
+    resizeSelection: {
+        en: 'Resize crop selection',
+        no: 'Endre størrelse på utvalget'
     }
 };
 export class ImgCropperLocalization {
-    get apply() {
-        return loc.apply[AppLocale.current];
-    }
-    get cancel() {
-        return loc.cancel[AppLocale.current];
-    }
     get imageLoadError() {
         return loc.imageLoadError[AppLocale.current];
     }
-    get initCropperError() {
-        return loc.initCropperError[AppLocale.current];
+    get resizeHandle() {
+        return loc.resizeHandle[AppLocale.current];
+    }
+    get resizeSelection() {
+        return loc.resizeSelection[AppLocale.current];
     }
 }

package/dist/ui/cropper/img-cropper/img-cropper-toolbar-localization.d.ts

@@ -1,11 +1,20 @@
 export declare class ImgCropperToolbarLocalization {
-    get move(): string;
-    get crop(): string;
+    get toolbar(): string;
+    get ratio(): string;
+    get original(): string;
+    get zoom(): string;
     get zoomIn(): string;
     get zoomOut(): string;
-    get rotate(): string;
+    get fillFrame(): string;
+    get fitFrame(): string;
+    get freePosition(): string;
+    get cropMode(): string;
+    get applyCrop(): string;
+    get align(): string;
+    get rotateLeft(): string;
+    get rotateRight(): string;
     get reset(): string;
-    get free(): string;
-    get ratio(): string;
     get fill(): string;
+    /** The label of one alignment cell; `fx` / `fy` are 0, 0.5 or 1 along each axis. */
+    alignPosition: (fx: number, fy: number) => string;
 }

package/dist/ui/cropper/img-cropper/img-cropper-toolbar-localization.js

@@ -1,48 +1,123 @@
 import { AppLocale } from '../../../core/locale';
 const loc = {
-    move: {
-        en: 'Move',
-        no: 'Flytt'
+    toolbar: {
+        en: 'Picture tools',
+        no: 'Bildeverktøy'
     },
-    crop: {
-        en: 'Crop',
-        no: 'Beskjær'
+    ratio: {
+        en: 'Aspect ratio',
+        no: 'Sideforhold'
+    },
+    original: {
+        en: 'Original',
+        no: 'Original'
+    },
+    zoom: {
+        en: 'Zoom',
+        no: 'Zoom'
     },
     zoomIn: {
-        en: 'Zoom In',
+        en: 'Zoom in',
         no: 'Zoom inn'
     },
     zoomOut: {
-        en: 'Zoom Out',
+        en: 'Zoom out',
         no: 'Zoom ut'
     },
-    rotate: {
-        en: 'Rotate',
-        no: 'Roter'
+    fillFrame: {
+        en: 'Fill frame',
+        no: 'Fyll rammen'
+    },
+    fitFrame: {
+        en: 'Fit inside frame',
+        no: 'Tilpass i rammen'
+    },
+    freePosition: {
+        en: 'Free position',
+        no: 'Fri plassering'
+    },
+    cropMode: {
+        en: 'Crop',
+        no: 'Beskjær'
+    },
+    applyCrop: {
+        en: 'Apply crop',
+        no: 'Bekreft beskjæring'
+    },
+    align: {
+        en: 'Align picture',
+        no: 'Juster bildet'
+    },
+    alignTopLeft: {
+        en: 'Top left',
+        no: 'Øverst til venstre'
+    },
+    alignTop: {
+        en: 'Top',
+        no: 'Øverst'
+    },
+    alignTopRight: {
+        en: 'Top right',
+        no: 'Øverst til høyre'
+    },
+    alignLeft: {
+        en: 'Left',
+        no: 'Venstre'
+    },
+    alignCenter: {
+        en: 'Center',
+        no: 'Midten'
+    },
+    alignRight: {
+        en: 'Right',
+        no: 'Høyre'
+    },
+    alignBottomLeft: {
+        en: 'Bottom left',
+        no: 'Nederst til venstre'
+    },
+    alignBottom: {
+        en: 'Bottom',
+        no: 'Nederst'
+    },
+    alignBottomRight: {
+        en: 'Bottom right',
+        no: 'Nederst til høyre'
+    },
+    rotateLeft: {
+        en: 'Rotate left',
+        no: 'Roter venstre'
+    },
+    rotateRight: {
+        en: 'Rotate right',
+        no: 'Roter høyre'
     },
     reset: {
         en: 'Reset',
         no: 'Tilbakestill'
     },
-    free: {
-        en: 'Free',
-        no: 'Fri'
-    },
-    ratio: {
-        en: 'Ratio',
-        no: 'Forhold'
-    },
     fill: {
-        en: 'Fill',
-        no: 'Fyll'
+        en: 'Fill color',
+        no: 'Fyllfarge'
     }
 };
+const ALIGN_KEYS = [
+    ['alignTopLeft', 'alignTop', 'alignTopRight'],
+    ['alignLeft', 'alignCenter', 'alignRight'],
+    ['alignBottomLeft', 'alignBottom', 'alignBottomRight']
+];
 export class ImgCropperToolbarLocalization {
-    get move() {
-        return loc.move[AppLocale.current];
+    get toolbar() {
+        return loc.toolbar[AppLocale.current];
     }
-    get crop() {
-        return loc.crop[AppLocale.current];
+    get ratio() {
+        return loc.ratio[AppLocale.current];
+    }
+    get original() {
+        return loc.original[AppLocale.current];
+    }
+    get zoom() {
+        return loc.zoom[AppLocale.current];
     }
     get zoomIn() {
         return loc.zoomIn[AppLocale.current];
@@ -50,19 +125,38 @@ export class ImgCropperToolbarLocalization {
     get zoomOut() {
         return loc.zoomOut[AppLocale.current];
     }
-    get rotate() {
-        return loc.rotate[AppLocale.current];
+    get fillFrame() {
+        return loc.fillFrame[AppLocale.current];
     }
-    get reset() {
-        return loc.reset[AppLocale.current];
+    get fitFrame() {
+        return loc.fitFrame[AppLocale.current];
     }
-    get free() {
-        return loc.free[AppLocale.current];
+    get freePosition() {
+        return loc.freePosition[AppLocale.current];
     }
-    get ratio() {
-        return loc.ratio[AppLocale.current];
+    get cropMode() {
+        return loc.cropMode[AppLocale.current];
+    }
+    get applyCrop() {
+        return loc.applyCrop[AppLocale.current];
+    }
+    get align() {
+        return loc.align[AppLocale.current];
+    }
+    get rotateLeft() {
+        return loc.rotateLeft[AppLocale.current];
+    }
+    get rotateRight() {
+        return loc.rotateRight[AppLocale.current];
+    }
+    get reset() {
+        return loc.reset[AppLocale.current];
     }
     get fill() {
         return loc.fill[AppLocale.current];
     }
+    /** The label of one alignment cell; `fx` / `fy` are 0, 0.5 or 1 along each axis. */
+    alignPosition = (fx, fy) => {
+        return loc[ALIGN_KEYS[Math.round(fy * 2)][Math.round(fx * 2)]][AppLocale.current];
+    };
 }

package/dist/ui/cropper/img-cropper/img-cropper-utils.d.ts

@@ -1,54 +1,7 @@
-import type { CanvasGeometry } from './img-cropper-worker.svelte';
-import type { CropperCanvas, CropperImage, CropperSelection } from 'cropperjs';
-type Rect = {
-    left: number;
-    top: number;
-    right: number;
-    bottom: number;
-};
 export declare const detectMimeFromUrl: (url: string) => string | null;
-export declare const computeImageScale: (transform: number[]) => number;
-export declare const computeNaturalOutputSize: (params: {
-    displayWidth: number;
-    displayHeight: number;
-    imageScale: number;
-}) => {
-    width: number;
-    height: number;
-};
-export declare const computeLocalAABB: (params: {
-    matrix: number[];
-    width: number;
-    height: number;
-}) => Rect;
-export declare const rectCoversRect: (inner: Rect, outer: Rect, tolerance?: number) => boolean;
-export declare const handleCoverCheck: (params: {
-    event: Event;
-    image: CropperImage;
-    canvas: CropperCanvas;
-}) => void;
-export declare const fitInContainer: (params: {
-    ratio: number;
-    containerWidth: number;
-    containerHeight: number;
-}) => {
-    width: number;
-    height: number;
-};
 /**
- * Applies the minimum canvas size by scaling the whole rect, bounded by `maxWidth` / `maxHeight`, and rounds to whole pixels.
- * The minimums are soft: a container smaller than them wins, and the returned canvas is smaller than `MIN_CANVAS_WIDTH` / `MIN_CANVAS_HEIGHT`.
+ * Whether the picture has any non-opaque pixel. Probed on a copy downscaled to `ALPHA_PROBE_PX` — downscaling averages
+ * alpha, so even thin transparent details still leave a sub-255 pixel, at a fraction of a full-resolution read.
  */
-export declare const resolveCanvasGeometry: (params: {
-    aspectRatio: number | null;
-    width: number;
-    height: number;
-    maxWidth: number;
-    maxHeight: number;
-}) => CanvasGeometry;
-export declare const handleSelectionBoundary: (params: {
-    event: Event;
-    selection: CropperSelection;
-    canvas: CropperCanvas;
-}) => void;
-export {};
+export declare const detectAlpha: (image: HTMLImageElement, mimeType: string | null) => boolean;
+export declare const loadImage: (src: string) => Promise<HTMLImageElement>;