@magicpages/kalotyp-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1976 @@
+class Dn {
+  listeners = /* @__PURE__ */ new Map();
+  on(n, e) {
+    let i = this.listeners.get(n);
+    return i || (i = /* @__PURE__ */ new Set(), this.listeners.set(n, i)), i.add(e), () => {
+      i?.delete(e);
+    };
+  }
+  off(n, e) {
+    this.listeners.get(n)?.delete(e);
+  }
+  emit(n, e) {
+    const i = this.listeners.get(n);
+    if (i)
+      for (const r of [...i])
+        try {
+          r(e);
+        } catch (o) {
+          queueMicrotask(() => {
+            throw o;
+          });
+        }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+async function Ln(t) {
+  if (typeof createImageBitmap == "function") {
+    const n = await wt(t);
+    if (n)
+      try {
+        const e = await createImageBitmap(n, { imageOrientation: "from-image" });
+        return { element: e, width: e.width, height: e.height };
+      } catch {
+      }
+  }
+  return xt(t);
+}
+async function wt(t) {
+  if (t instanceof Blob) return t;
+  if (typeof fetch != "function") return null;
+  try {
+    const n = await fetch(t, { credentials: "omit" });
+    return n.ok ? await n.blob() : null;
+  } catch {
+    return null;
+  }
+}
+async function xt(t) {
+  const n = typeof t == "string" ? t : URL.createObjectURL(t), e = typeof t != "string";
+  try {
+    const i = await new Promise((r, o) => {
+      const a = new Image();
+      a.crossOrigin = "anonymous", a.onload = () => r(a), a.onerror = () => o(new Error(`Failed to load image: ${n}`)), a.src = n;
+    });
+    return {
+      element: i,
+      width: i.naturalWidth,
+      height: i.naturalHeight
+    };
+  } finally {
+    e && URL.revokeObjectURL(n);
+  }
+}
+const k = Object.freeze({
+  zoom: 1,
+  panX: 0,
+  panY: 0
+});
+function pt(t, n, e = k) {
+  const i = Math.max(0, t.width - t.padding * 2), r = Math.max(0, t.height - t.padding * 2);
+  if (n.width <= 0 || n.height <= 0 || i <= 0 || r <= 0)
+    return {
+      displayRect: { x: t.padding, y: t.padding, width: 0, height: 0 },
+      scale: 0
+    };
+  const o = Math.min(i / n.width, r / n.height), a = Math.max(0, e.zoom || 0), c = o * a, l = n.width * c, s = n.height * c, u = t.padding + (i - l) / 2, h = t.padding + (r - s) / 2, f = u + e.panX, d = h + e.panY, m = z(f, u, l, i, t.padding), p = z(d, h, s, r, t.padding);
+  return {
+    displayRect: { x: m, y: p, width: l, height: s },
+    scale: c
+  };
+}
+function z(t, n, e, i, r) {
+  if (e <= i) return n;
+  const o = r, a = r + i, c = o + 1 - e, l = a - 1;
+  return t < c ? c : t > l ? l : t;
+}
+function Bn(t, n) {
+  return {
+    x: n.displayRect.x + t.x * n.scale,
+    y: n.displayRect.y + t.y * n.scale
+  };
+}
+function Wn(t, n) {
+  return n.scale === 0 ? { x: 0, y: 0 } : {
+    x: (t.x - n.displayRect.x) / n.scale,
+    y: (t.y - n.displayRect.y) / n.scale
+  };
+}
+function Yn(t, n) {
+  return {
+    x: n.displayRect.x + t.x * n.scale,
+    y: n.displayRect.y + t.y * n.scale,
+    width: t.width * n.scale,
+    height: t.height * n.scale
+  };
+}
+function Xn(t, n) {
+  return n.scale === 0 ? { x: 0, y: 0, width: 0, height: 0 } : {
+    x: (t.x - n.displayRect.x) / n.scale,
+    y: (t.y - n.displayRect.y) / n.scale,
+    width: t.width / n.scale,
+    height: t.height / n.scale
+  };
+}
+const ot = 8, at = 0.25;
+class Un {
+  current;
+  isPinching;
+  listeners;
+  constructor(n = k) {
+    this.current = D(n), this.isPinching = !1, this.listeners = /* @__PURE__ */ new Set();
+  }
+  getTransform() {
+    return this.current;
+  }
+  getSnapshot() {
+    return { transform: this.current, pinching: this.isPinching };
+  }
+  setTransform(n) {
+    const e = D(n);
+    L(this.current, e) || (this.current = e, this.emit());
+  }
+  /**
+   * Apply a multiplicative zoom delta anchored on a stage CSS-pixel point.
+   * The point under `anchor` stays under `anchor` after the zoom.
+   *
+   * Pan is the displaced image-center's offset from the stage center, so the
+   * dolly-zoom reduces to `pan_new = ratio · pan_old + (1 − ratio) · (anchor − stageCenter)`,
+   * independent of the active plugin's image intrinsic.
+   */
+  zoomAt(n, e, i) {
+    if (!Number.isFinite(n) || n <= 0) return this.current;
+    const r = this.current.zoom, o = r * n, a = ct(o, at, ot);
+    if (a === r) return this.current;
+    const c = a / r, l = e.x - i.x, s = e.y - i.y, u = c * this.current.panX + (1 - c) * l, h = c * this.current.panY + (1 - c) * s;
+    return this.current = { zoom: a, panX: u, panY: h }, this.emit(), this.current;
+  }
+  /**
+   * Translate pan by `(dx, dy)` in stage CSS pixels at the current zoom.
+   * Pan is stored raw; `computeViewport` clamps at emission time so the
+   * gesture handler's math stays stable when the user pans past the clamp.
+   */
+  panBy(n, e) {
+    n === 0 && e === 0 || (this.current = {
+      zoom: this.current.zoom,
+      panX: this.current.panX + n,
+      panY: this.current.panY + e
+    }, this.emit());
+  }
+  resetToFit() {
+    L(this.current, k) || (this.current = k, this.emit());
+  }
+  /** Reset only the pan, preserving zoom. Used on plugin switch. */
+  resetPan() {
+    this.current.panX === 0 && this.current.panY === 0 || (this.current = { zoom: this.current.zoom, panX: 0, panY: 0 }, this.emit());
+  }
+  /** True while a multi-pointer gesture is active. Heavy plugins read this. */
+  getPinching() {
+    return this.isPinching;
+  }
+  setPinching(n) {
+    this.isPinching !== n && (this.isPinching = n, this.emit());
+  }
+  computeViewport(n, e) {
+    return pt(n, e, this.current);
+  }
+  /** Subscribe to transform / pinching changes. Handler runs synchronously after every change. */
+  subscribe(n) {
+    return this.listeners.add(n), () => {
+      this.listeners.delete(n);
+    };
+  }
+  clear() {
+    this.listeners.clear();
+  }
+  emit() {
+    const n = this.getSnapshot();
+    for (const e of this.listeners) e(n);
+  }
+}
+function ct(t, n, e) {
+  return t < n ? n : t > e ? e : t;
+}
+function D(t) {
+  const n = ct(Number.isFinite(t.zoom) ? t.zoom : 1, at, ot), e = Number.isFinite(t.panX) ? t.panX : 0, i = Number.isFinite(t.panY) ? t.panY : 0;
+  return { zoom: n, panX: e, panY: i };
+}
+function L(t, n) {
+  return t.zoom === n.zoom && t.panX === n.panX && t.panY === n.panY;
+}
+function g(t, n) {
+  if (Mt())
+    return { kind: "offscreen", canvas: new OffscreenCanvas(t, n) };
+  const e = document.createElement("canvas");
+  return e.width = t, e.height = n, { kind: "html", canvas: e };
+}
+function y(t) {
+  if (t.kind === "offscreen") {
+    const e = t.canvas.getContext("2d");
+    if (!e) throw new Error("2D canvas context is not available");
+    return e;
+  }
+  const n = t.canvas.getContext("2d");
+  if (!n) throw new Error("2D canvas context is not available");
+  return n;
+}
+async function st(t, n, e) {
+  return t.kind === "offscreen" ? t.canvas.convertToBlob({ type: n, quality: e }) : new Promise((i, r) => {
+    t.canvas.toBlob(
+      (o) => {
+        o ? i(o) : r(new Error("toBlob produced null"));
+      },
+      n,
+      e
+    );
+  });
+}
+function Mt() {
+  return typeof OffscreenCanvas > "u" ? !1 : typeof OffscreenCanvas.prototype.convertToBlob == "function";
+}
+const B = /* @__PURE__ */ new Map();
+function b(t) {
+  const n = B.get(t);
+  if (n) return n;
+  const e = (async () => {
+    try {
+      const i = g(1, 1), r = await st(i, t, 0.5);
+      return r.type === t && r.size > 0;
+    } catch {
+      return !1;
+    }
+  })();
+  return B.set(t, e), e;
+}
+function Hn(t, n) {
+  const e = Math.min(t.x, n.x), i = Math.min(t.y, n.y), r = Math.abs(t.x - n.x), o = Math.abs(t.y - n.y);
+  return { x: e, y: i, width: r, height: o };
+}
+function qn(t) {
+  return t.x + t.width;
+}
+function jn(t) {
+  return t.y + t.height;
+}
+function $n(t) {
+  return { x: t.x + t.width / 2, y: t.y + t.height / 2 };
+}
+function Qn(t, n) {
+  return t.x >= n.x && t.x <= n.x + n.width && t.y >= n.y && t.y <= n.y + n.height;
+}
+function Kn(t, n) {
+  return t.x === n.x && t.y === n.y && t.width === n.width && t.height === n.height;
+}
+function Vn(t, n, e, i) {
+  const r = { x: t.x + n, y: t.y + e, width: t.width, height: t.height };
+  return P(r, i);
+}
+function P(t, n) {
+  let { x: e, y: i, width: r, height: o } = t;
+  return r > n.width && (r = n.width), o > n.height && (o = n.height), e < n.x && (e = n.x), i < n.y && (i = n.y), e + r > n.x + n.width && (e = n.x + n.width - r), i + o > n.y + n.height && (i = n.y + n.height - o), { x: e, y: i, width: r, height: o };
+}
+function St(t) {
+  return {
+    x: Math.round(t.x),
+    y: Math.round(t.y),
+    width: Math.round(t.width),
+    height: Math.round(t.height)
+  };
+}
+function Gn(t) {
+  let n = t;
+  const e = /* @__PURE__ */ new Set();
+  function i(r) {
+    for (const o of [...e])
+      try {
+        o(n, r);
+      } catch (a) {
+        queueMicrotask(() => {
+          throw a;
+        });
+      }
+  }
+  return {
+    get() {
+      return n;
+    },
+    set(r) {
+      const o = n;
+      n = { ...n, ...r }, i(o);
+    },
+    update(r) {
+      const o = n;
+      n = { ...n, ...r(n) }, i(o);
+    },
+    subscribe(r) {
+      return e.add(r), () => e.delete(r);
+    }
+  };
+}
+const W = 50;
+class Jn {
+  shadow;
+  undoStack = [];
+  redoStack = [];
+  constructor(n) {
+    this.shadow = E(n);
+  }
+  /**
+   * Capture a commit. Previous shadow → undo stack; `current` → shadow.
+   * Redo is cleared because a new commit branches the history. A commit
+   * structurally equal to the shadow is a no-op so duplicates (clicking
+   * the same preset twice) don't pollute the undo stack.
+   */
+  commit(n) {
+    bt(n, this.shadow) || (this.undoStack.push(this.shadow), this.undoStack.length > W && this.undoStack.shift(), this.shadow = E(n), this.redoStack.length = 0);
+  }
+  canUndo() {
+    return this.undoStack.length > 0;
+  }
+  canRedo() {
+    return this.redoStack.length > 0;
+  }
+  /** Pop the most recent prior snapshot; `current` goes onto the redo stack. Returns null if undo is empty. */
+  undo(n) {
+    const e = this.undoStack.pop();
+    return e ? (this.redoStack.push(E(n)), this.shadow = e, { snapshot: e, changed: Y(n, e) }) : null;
+  }
+  /** Pop the most recent redo entry; `current` goes onto the undo stack. Returns null if redo is empty. */
+  redo(n) {
+    const e = this.redoStack.pop();
+    return e ? (this.undoStack.push(E(n)), this.undoStack.length > W && this.undoStack.shift(), this.shadow = e, { snapshot: e, changed: Y(n, e) }) : null;
+  }
+  /** Test/debug helpers; not part of the editor's runtime API. */
+  size() {
+    return { undo: this.undoStack.length, redo: this.redoStack.length };
+  }
+}
+function bt(t, n) {
+  if (t.size !== n.size) return !1;
+  for (const [e, i] of t)
+    if (!n.has(e) || C(i) !== C(n.get(e))) return !1;
+  return !0;
+}
+function Y(t, n) {
+  const e = /* @__PURE__ */ new Set();
+  for (const [i, r] of n)
+    C(r) !== C(t.get(i)) && e.add(i);
+  for (const i of t.keys())
+    n.has(i) || e.add(i);
+  return e;
+}
+function E(t) {
+  const n = /* @__PURE__ */ new Map();
+  for (const [e, i] of t)
+    n.set(e, structuredClone(i));
+  return n;
+}
+function C(t) {
+  return JSON.stringify(t, (n, e) => {
+    if (e && typeof e == "object" && !Array.isArray(e)) {
+      const i = {};
+      for (const r of Object.keys(e).sort())
+        i[r] = e[r];
+      return i;
+    }
+    return e;
+  });
+}
+function O(t, n) {
+  if (n <= 0 || t.width <= 0 || t.height <= 0)
+    return { x: t.x, y: t.y, width: 0, height: 0 };
+  const e = t.width / t.height;
+  let i, r;
+  return n >= e ? (i = t.width, r = i / n) : (r = t.height, i = r * n), {
+    x: t.x + (t.width - i) / 2,
+    y: t.y + (t.height - r) / 2,
+    width: i,
+    height: r
+  };
+}
+function Et(t, n, e, i) {
+  if (n <= 0) return t;
+  if (t.width <= 0 || t.height <= 0) return O(i, n);
+  const r = t.width / t.height;
+  let o, a;
+  r > n ? (a = t.height, o = a * n) : (o = t.width, a = o / n);
+  const c = lt(t, o, a, e), l = P(c, i), s = l.height === 0 ? 0 : l.width / l.height;
+  return Math.abs(s - n) <= Rt ? l : It(l, n, e);
+}
+const Rt = 1e-6;
+function lt(t, n, e, i) {
+  switch (i) {
+    case "tl":
+      return { x: t.x, y: t.y, width: n, height: e };
+    case "tr":
+      return { x: t.x + t.width - n, y: t.y, width: n, height: e };
+    case "bl":
+      return { x: t.x, y: t.y + t.height - e, width: n, height: e };
+    case "br":
+      return {
+        x: t.x + t.width - n,
+        y: t.y + t.height - e,
+        width: n,
+        height: e
+      };
+    case "center":
+      return {
+        x: t.x + (t.width - n) / 2,
+        y: t.y + (t.height - e) / 2,
+        width: n,
+        height: e
+      };
+  }
+}
+function It(t, n, e) {
+  const i = O(t, n);
+  return lt(t, i.width, i.height, e);
+}
+function Zn(t, n, e, i) {
+  const r = i.minSize ?? 1, o = t.x, a = t.y, c = t.x + t.width, l = t.y + t.height;
+  let s = o, u = a, h = c, f = l;
+  (n === "tl" || n === "l" || n === "bl") && (s = e.x), (n === "tr" || n === "r" || n === "br") && (h = e.x), (n === "tl" || n === "t" || n === "tr") && (u = e.y), (n === "bl" || n === "b" || n === "br") && (f = e.y), (n === "l" || n === "r") && (u = a, f = l), (n === "t" || n === "b") && (s = o, h = c);
+  let d = Math.min(s, h), m = Math.min(u, f), p = Math.abs(h - s), A = Math.abs(f - u);
+  p < r && (p = r, n === "tl" || n === "l" || n === "bl" ? d = c - r : (n === "tr" || n === "r" || n === "br") && (d = o)), A < r && (A = r, n === "tl" || n === "t" || n === "tr" ? m = l - r : (n === "bl" || n === "b" || n === "br") && (m = a));
+  let M = { x: d, y: m, width: p, height: A };
+  return M = P(M, i.bounds), i.aspectRatio !== void 0 && i.aspectRatio > 0 && (M = Et(M, i.aspectRatio, Tt(n), i.bounds)), M;
+}
+function Tt(t) {
+  switch (t) {
+    case "tl":
+      return "br";
+    case "tr":
+      return "bl";
+    case "bl":
+      return "tr";
+    case "br":
+      return "tl";
+    case "t":
+      return "bl";
+    case "b":
+      return "tl";
+    case "l":
+      return "tr";
+    case "r":
+      return "tl";
+  }
+}
+function kt(t, n) {
+  const [e] = t;
+  return e === void 0 || n === void 0 ? !0 : n === "landscape" ? e >= 1 : n === "portrait" ? e < 1 : !0;
+}
+function te(t, n) {
+  return t.filter((e) => kt(e, n));
+}
+function ne(t) {
+  return {
+    rect: { x: 0, y: 0, width: t.imageSize.width, height: t.imageSize.height },
+    aspectRatio: void 0,
+    activePresetIndex: Ct(t.presets),
+    presets: t.presets,
+    imageSize: t.imageSize
+  };
+}
+function ee(t, n) {
+  const e = t.presets[n];
+  if (!e) return t;
+  const [i] = e;
+  if (i === void 0)
+    return { ...t, aspectRatio: void 0, activePresetIndex: n };
+  const r = {
+    x: 0,
+    y: 0,
+    width: t.imageSize.width,
+    height: t.imageSize.height
+  }, o = O(r, i);
+  return { ...t, rect: o, aspectRatio: i, activePresetIndex: n };
+}
+function Ct(t) {
+  return t.findIndex(([n]) => n === void 0);
+}
+function ie(t, n) {
+  const e = St(n.rect), i = R(e.x, 0, t.width), r = R(e.y, 0, t.height), o = R(e.width, 1, t.width - i), a = R(e.height, 1, t.height - r), c = g(o, a);
+  if (c.kind === "offscreen") {
+    const s = c.canvas.getContext("2d");
+    if (!s) throw new Error("2D canvas context is not available");
+    return s.drawImage(t.bitmap, i, r, o, a, 0, 0, o, a), { bitmap: c.canvas, width: o, height: a, mimeType: t.mimeType };
+  }
+  const l = c.canvas.getContext("2d");
+  if (!l) throw new Error("2D canvas context is not available");
+  return l.drawImage(t.bitmap, i, r, o, a, 0, 0, o, a), { bitmap: c.canvas, width: o, height: a, mimeType: t.mimeType };
+}
+function R(t, n, e) {
+  return Math.max(n, Math.min(e, t));
+}
+const ut = {
+  mimeChoice: "auto",
+  quality: 0.85,
+  stripMetadata: !0
+}, re = [
+  "image/png",
+  "image/jpeg",
+  "image/webp",
+  "image/avif"
+];
+function ht(t) {
+  return Number.isFinite(t) ? t < 0 ? 0 : t > 1 ? 1 : t : ut.quality;
+}
+function oe(t, n) {
+  return t.mimeChoice === n ? t : { ...t, mimeChoice: n };
+}
+function ae(t, n) {
+  const e = ht(n);
+  return t.quality === e ? t : { ...t, quality: e };
+}
+function ce(t, n) {
+  return t.stripMetadata === n ? t : { ...t, stripMetadata: n };
+}
+const X = [255, 216], U = [255, 225], H = [69, 120, 105, 102, 0, 0];
+async function vt(t) {
+  if (t.output.type && t.output.type !== "image/jpeg") return t.output;
+  const n = await q(t.source);
+  if (!j(n, X)) return t.output;
+  const e = At(n);
+  if (!e) return t.output;
+  const i = await q(t.output);
+  if (!j(i, X)) return t.output;
+  const r = new Uint8Array(i.length + e.length);
+  return r.set(i.subarray(0, 2), 0), r.set(e, 2), r.set(i.subarray(2), 2 + e.length), new Blob([r], { type: "image/jpeg" });
+}
+async function q(t) {
+  return typeof t.arrayBuffer == "function" ? new Uint8Array(await t.arrayBuffer()) : new Promise((n, e) => {
+    const i = new FileReader();
+    i.onload = () => {
+      const r = i.result;
+      r instanceof ArrayBuffer ? n(new Uint8Array(r)) : e(new Error("FileReader returned a non-ArrayBuffer result"));
+    }, i.onerror = () => e(i.error ?? new Error("FileReader failed")), i.readAsArrayBuffer(t);
+  });
+}
+function j(t, n) {
+  if (t.length < n.length) return !1;
+  for (let e = 0; e < n.length; e++)
+    if (t[e] !== n[e]) return !1;
+  return !0;
+}
+function At(t) {
+  let n = 2;
+  for (; n + 4 <= t.length; ) {
+    if (t[n] !== 255) return;
+    const e = t[n + 1];
+    if (e === void 0 || e === 218 || e === 217) return;
+    const i = t[n + 2] !== void 0 && t[n + 3] !== void 0 ? t[n + 2] * 256 + t[n + 3] : 0;
+    if (i < 2) return;
+    const r = n + 2 + i;
+    if (r > t.length) return;
+    if (t[n] === U[0] && t[n + 1] === U[1] && Nt(t, n + 4))
+      return t.slice(n, r);
+    n = r;
+  }
+}
+function Nt(t, n) {
+  for (let e = 0; e < H.length; e++)
+    if (t[n + e] !== H[e]) return !1;
+  return !0;
+}
+const $ = "image/png", Ft = /* @__PURE__ */ new Set(["image/png", "image/webp", "image/avif"]);
+async function Pt(t, n) {
+  return t.mimeChoice !== "auto" ? await b(t.mimeChoice) ? t.mimeChoice : await b("image/webp") ? "image/webp" : $ : await b("image/webp") ? "image/webp" : !Ft.has(n.mimeType) && await b("image/jpeg") ? "image/jpeg" : $;
+}
+function Ot(t, n) {
+  const e = _t(n);
+  if (!t) return `kalotyp-image.${e}`;
+  const i = zt(t);
+  if (!i) return `kalotyp-image.${e}`;
+  const r = Lt(i);
+  return r ? `${r}.${e}` : `kalotyp-image.${e}`;
+}
+async function se(t, n = {}) {
+  const e = n.output ?? ut, i = await Pt(e, t), r = ht(e.quality), o = Ot(n.sourceName, i), a = g(t.width, t.height);
+  if (a.kind === "offscreen") {
+    const u = a.canvas.getContext("2d");
+    if (!u) throw new Error("2D canvas context is not available");
+    u.drawImage(t.bitmap, 0, 0);
+  } else {
+    const u = a.canvas.getContext("2d");
+    if (!u) throw new Error("2D canvas context is not available");
+    u.drawImage(t.bitmap, 0, 0);
+  }
+  const c = await st(a, i, r), s = n.output?.stripMetadata === !1 && i === "image/jpeg" && t.mimeType === "image/jpeg" && n.sourceBlob !== void 0 ? await vt({ source: n.sourceBlob, output: c }) : c;
+  return new File([s], o, { type: i });
+}
+function _t(t) {
+  if (t === "image/jpeg") return "jpg";
+  if (t === "image/png") return "png";
+  if (t === "image/webp") return "webp";
+  if (t === "image/avif") return "avif";
+  const n = t.split("/")[1];
+  return n && n.length > 0 ? n : "bin";
+}
+function zt(t) {
+  const e = Dt(t).split(/[/\\]/);
+  return e[e.length - 1];
+}
+function Dt(t) {
+  const n = t.indexOf("?");
+  return n === -1 ? t : t.slice(0, n);
+}
+function Lt(t) {
+  const n = t.lastIndexOf(".");
+  return n <= 0 ? t : t.slice(0, n);
+}
+async function le(t, n) {
+  let e = n;
+  for (const i of t)
+    e = await i.plugin.bake(i.state, e);
+  return e;
+}
+function ue() {
+  return { horizontal: !1, vertical: !1 };
+}
+function he(t, n) {
+  return n === "horizontal" ? { ...t, horizontal: !t.horizontal } : { ...t, vertical: !t.vertical };
+}
+function Bt(t) {
+  return !t.horizontal && !t.vertical;
+}
+async function fe(t, n) {
+  if (Bt(t)) return n;
+  const { width: e, height: i } = n, r = g(e, i), o = y(r), a = t.horizontal ? -1 : 1, c = t.vertical ? -1 : 1, l = t.horizontal ? e : 0, s = t.vertical ? i : 0;
+  return o.setTransform(a, 0, 0, c, l, s), o.drawImage(n.bitmap, 0, 0), {
+    bitmap: r.canvas,
+    width: e,
+    height: i,
+    mimeType: n.mimeType
+  };
+}
+const Wt = -45, Yt = 45, de = 0.1;
+function ge() {
+  return { quarterTurns: 0, freeAngle: 0 };
+}
+function me(t) {
+  return { ...t, quarterTurns: (t.quarterTurns + 1) % 4 };
+}
+function ye(t) {
+  return { ...t, quarterTurns: (t.quarterTurns + 3) % 4 };
+}
+function we(t, n) {
+  const e = Ht(n, Wt, Yt), i = Math.round(e * 10) / 10;
+  return { ...t, freeAngle: i };
+}
+function Xt(t) {
+  return t.quarterTurns === 0 && Math.abs(t.freeAngle) < 1e-6;
+}
+function Ut(t) {
+  return t.quarterTurns * 90 + t.freeAngle;
+}
+function Ht(t, n, e) {
+  return Math.max(n, Math.min(e, t));
+}
+function qt(t, n) {
+  const e = t.width, i = t.height;
+  if (e <= 0 || i <= 0) return { width: 0, height: 0 };
+  const r = Math.abs(Math.cos(n)), o = Math.abs(Math.sin(n)), a = e * r + i * o, c = e * o + i * r, l = a > Q ? e * e / a : Number.POSITIVE_INFINITY, s = c > Q ? e * i / c : Number.POSITIVE_INFINITY, u = Math.min(l, s), h = u * i / e;
+  return { width: u, height: h };
+}
+const Q = 1e-9;
+async function xe(t, n) {
+  if (Xt(t)) return n;
+  const e = Ut(t), i = e * Math.PI / 180, r = e - t.quarterTurns * 90, o = Math.abs(r) < 1e-6;
+  let a, c;
+  if (o)
+    t.quarterTurns === 1 || t.quarterTurns === 3 ? (a = n.height, c = n.width) : (a = n.width, c = n.height);
+  else {
+    const u = qt(n, i);
+    a = Math.max(1, Math.round(u.width)), c = Math.max(1, Math.round(u.height));
+  }
+  const l = g(a, c), s = y(l);
+  return s.imageSmoothingEnabled = !0, s.imageSmoothingQuality = "high", s.translate(a / 2, c / 2), s.rotate(i), s.drawImage(n.bitmap, -n.width / 2, -n.height / 2), {
+    bitmap: l.canvas,
+    width: a,
+    height: c,
+    mimeType: n.mimeType
+  };
+}
+const ft = 8e3, K = 1;
+function pe() {
+  return { scaleX: 1, scaleY: 1, lockAspect: !0 };
+}
+function jt(t) {
+  return Math.abs(t.scaleX - 1) < 1e-9 && Math.abs(t.scaleY - 1) < 1e-9;
+}
+function $t(t, n) {
+  const e = v(Math.round(n.width * t.scaleX)), i = v(Math.round(n.height * t.scaleY));
+  return { width: e, height: i };
+}
+function Me(t, n, e) {
+  if (e.width <= 0) return t;
+  const r = v(Math.round(n)) / e.width, o = t.lockAspect ? r : t.scaleY;
+  return { ...t, scaleX: r, scaleY: o };
+}
+function Se(t, n, e) {
+  if (e.height <= 0) return t;
+  const r = v(Math.round(n)) / e.height, o = t.lockAspect ? r : t.scaleX;
+  return { ...t, scaleX: o, scaleY: r };
+}
+function be(t, n) {
+  const e = Qt(n / 100);
+  return { ...t, scaleX: e, scaleY: e };
+}
+function Ee(t, n) {
+  if (t.lockAspect === n) return t;
+  if (!n) return { ...t, lockAspect: !1 };
+  const e = (t.scaleX + t.scaleY) / 2;
+  return { scaleX: e, scaleY: e, lockAspect: !0 };
+}
+function Re(t) {
+  const n = Math.max(t.scaleX, t.scaleY);
+  return Math.round(n * 1e3) / 10;
+}
+function v(t) {
+  return Number.isFinite(t) ? Math.max(K, Math.min(ft, Math.trunc(t))) : K;
+}
+function Qt(t) {
+  return !Number.isFinite(t) || t <= 0 ? 0.01 : Math.max(0.01, Math.min(t, ft));
+}
+async function Ie(t, n) {
+  if (jt(t)) return n;
+  const { width: e, height: i } = $t(t, n);
+  if (e <= 0 || i <= 0) return n;
+  const r = Kt(n.width, n.height, e, i);
+  let o = {
+    bitmap: n.bitmap,
+    width: n.width,
+    height: n.height
+  };
+  for (let c = 0; c < r; c++) {
+    const l = Math.max(e, Math.floor(o.width / 2)), s = Math.max(i, Math.floor(o.height / 2));
+    o = { bitmap: V(o, l, s).canvas, width: l, height: s };
+  }
+  return {
+    bitmap: V(o, e, i).canvas,
+    width: e,
+    height: i,
+    mimeType: n.mimeType
+  };
+}
+function Kt(t, n, e, i) {
+  let r = t, o = n, a = 0;
+  for (; (r / 2 > e || o / 2 > i) && a < 16; )
+    r = Math.floor(r / 2), o = Math.floor(o / 2), a += 1;
+  return a;
+}
+function V(t, n, e) {
+  const i = g(n, e), r = y(i);
+  return r.imageSmoothingEnabled = !0, r.imageSmoothingQuality = "high", r.drawImage(t.bitmap, 0, 0, t.width, t.height, 0, 0, n, e), i;
+}
+const G = -100, J = 100, Z = 1, _ = {
+  brightness: 0,
+  contrast: 0,
+  saturation: 0,
+  exposure: 0,
+  clarity: 0,
+  gamma: 0
+}, Te = [
+  { key: "brightness", label: "Brightness" },
+  { key: "contrast", label: "Contrast" },
+  { key: "saturation", label: "Saturation" },
+  { key: "exposure", label: "Exposure" },
+  { key: "clarity", label: "Clarity" },
+  { key: "gamma", label: "Gamma" }
+];
+function ke() {
+  return _;
+}
+function Vt(t) {
+  return t.brightness === 0 && t.contrast === 0 && t.saturation === 0 && t.exposure === 0 && t.clarity === 0 && t.gamma === 0;
+}
+function Ce(t, n, e) {
+  const i = Gt(e);
+  return t[n] === i ? t : { ...t, [n]: i };
+}
+function ve(t, n) {
+  return t[n] === 0 ? t : { ...t, [n]: 0 };
+}
+function Ae() {
+  return _;
+}
+function Gt(t) {
+  return Number.isNaN(t) ? 0 : t <= G ? G : t >= J ? J : Math.round(t / Z) * Z;
+}
+function Jt(t) {
+  const n = new Uint8ClampedArray(256), e = t.brightness / 200, i = 1 + t.contrast / 100, r = 1 + t.exposure / 200, o = Zt(t.gamma);
+  for (let a = 0; a < 256; a++) {
+    let c = a / 255;
+    c = c * r, c = (c - 0.5) * i + 0.5, c = c + e, c < 0 ? c = 0 : c > 1 && (c = 1), c = c ** o, c < 0 ? c = 0 : c > 1 && (c = 1), n[a] = Math.round(c * 255);
+  }
+  return n;
+}
+function Zt(t) {
+  return t === 0 ? 1 : t > 0 ? 1 - 0.5 * (t / 100) : 1 + 1 * (-t / 100);
+}
+function tn(t, n, e, i) {
+  const r = t.length;
+  if (n.length !== r)
+    throw new Error("applyFinetuneLutAndSaturation: src/dst length mismatch");
+  const o = 1 + i.saturation / 100;
+  if (o === 1) {
+    for (let a = 0; a < r; a += 4)
+      n[a] = e[t[a]], n[a + 1] = e[t[a + 1]], n[a + 2] = e[t[a + 2]], n[a + 3] = t[a + 3];
+    return;
+  }
+  for (let a = 0; a < r; a += 4) {
+    const c = e[t[a]], l = e[t[a + 1]], s = e[t[a + 2]], u = 0.2126 * c + 0.7152 * l + 0.0722 * s;
+    let h = u + (c - u) * o, f = u + (l - u) * o, d = u + (s - u) * o;
+    h < 0 ? h = 0 : h > 255 && (h = 255), f < 0 ? f = 0 : f > 255 && (f = 255), d < 0 ? d = 0 : d > 255 && (d = 255), n[a] = h, n[a + 1] = f, n[a + 2] = d, n[a + 3] = t[a + 3];
+  }
+}
+function nn(t, n, e) {
+  if (e === 0) return;
+  const i = t.length;
+  if (n.length !== i)
+    throw new Error("applyClarity: dst/blurred length mismatch");
+  const r = e / 100;
+  for (let o = 0; o < i; o += 4) {
+    const a = t[o], c = t[o + 1], l = t[o + 2];
+    let s = a + r * (a - n[o]), u = c + r * (c - n[o + 1]), h = l + r * (l - n[o + 2]);
+    s < 0 ? s = 0 : s > 255 && (s = 255), u < 0 ? u = 0 : u > 255 && (u = 255), h < 0 ? h = 0 : h > 255 && (h = 255), t[o] = s, t[o + 1] = u, t[o + 2] = h;
+  }
+}
+function en(t, n, e, i, r) {
+  if (t.length !== n.length || t.length !== e.length)
+    throw new Error("boxBlur3x3: buffer length mismatch");
+  for (let o = 0; o < r; o++)
+    for (let a = 0; a < i; a++) {
+      const c = a === 0 ? 0 : a - 1, l = a === i - 1 ? i - 1 : a + 1, s = (o * i + a) * 4, u = (o * i + c) * 4, h = (o * i + l) * 4;
+      n[s] = (t[u] + t[s] + t[h]) / 3, n[s + 1] = (t[u + 1] + t[s + 1] + t[h + 1]) / 3, n[s + 2] = (t[u + 2] + t[s + 2] + t[h + 2]) / 3, n[s + 3] = t[s + 3];
+    }
+  for (let o = 0; o < r; o++) {
+    const a = o === 0 ? 0 : o - 1, c = o === r - 1 ? r - 1 : o + 1;
+    for (let l = 0; l < i; l++) {
+      const s = (o * i + l) * 4, u = (a * i + l) * 4, h = (c * i + l) * 4;
+      e[s] = (n[u] + n[s] + n[h]) / 3, e[s + 1] = (n[u + 1] + n[s + 1] + n[h + 1]) / 3, e[s + 2] = (n[u + 2] + n[s + 2] + n[h + 2]) / 3, e[s + 3] = n[s + 3];
+    }
+  }
+}
+function tt(t, n, e) {
+  if (n.width !== e.width || n.height !== e.height || n.data.length !== e.data.length)
+    throw new Error("applyFinetuneToImageData: baseline/dst dimensions mismatch");
+  const i = Jt(t);
+  if (tn(n.data, e.data, i, t), t.clarity !== 0) {
+    const r = new Uint8ClampedArray(n.data.length), o = new Uint8ClampedArray(n.data.length);
+    en(n.data, r, o, n.width, n.height), nn(e.data, o, t.clarity);
+  }
+}
+async function Ne(t, n) {
+  if (Vt(t)) return n;
+  const e = g(n.width, n.height), i = y(e);
+  i.imageSmoothingEnabled = !0, i.imageSmoothingQuality = "high", i.drawImage(n.bitmap, 0, 0, n.width, n.height);
+  const r = i.getImageData(0, 0, n.width, n.height);
+  if (t.clarity === 0)
+    tt(t, r, r), i.putImageData(r, 0, 0);
+  else {
+    const o = new ImageData(
+      new Uint8ClampedArray(r.data.length),
+      r.width,
+      r.height
+    );
+    tt(t, r, o), i.putImageData(o, 0, 0);
+  }
+  return {
+    bitmap: e.canvas,
+    width: n.width,
+    height: n.height,
+    mimeType: n.mimeType
+  };
+}
+const rn = [
+  {
+    id: "none",
+    label: "None",
+    state: _
+  },
+  {
+    id: "vivid",
+    label: "Vivid",
+    state: {
+      brightness: 0,
+      contrast: 10,
+      saturation: 40,
+      exposure: 0,
+      clarity: 5,
+      gamma: 0
+    }
+  },
+  {
+    id: "mono",
+    label: "Mono",
+    // -100 saturation is bit-exact grayscale via Rec. 709 luminance.
+    state: {
+      brightness: 0,
+      contrast: 15,
+      saturation: -100,
+      exposure: 0,
+      clarity: 0,
+      gamma: 0
+    }
+  },
+  {
+    id: "soft",
+    label: "Soft",
+    state: {
+      brightness: 5,
+      contrast: -10,
+      saturation: 0,
+      exposure: 0,
+      clarity: -25,
+      gamma: 0
+    }
+  },
+  {
+    id: "punch",
+    label: "Punch",
+    state: {
+      brightness: 0,
+      contrast: 30,
+      saturation: 5,
+      exposure: 0,
+      clarity: 25,
+      gamma: 0
+    }
+  },
+  {
+    id: "mute",
+    label: "Mute",
+    state: {
+      brightness: 0,
+      contrast: 5,
+      saturation: -50,
+      exposure: 0,
+      clarity: -5,
+      gamma: 0
+    }
+  },
+  {
+    id: "bright",
+    label: "Bright",
+    state: {
+      brightness: 5,
+      contrast: 5,
+      saturation: 0,
+      exposure: 15,
+      clarity: 0,
+      gamma: 0
+    }
+  }
+];
+function on(t, n) {
+  return t.brightness === n.brightness && t.contrast === n.contrast && t.saturation === n.saturation && t.exposure === n.exposure && t.clarity === n.clarity && t.gamma === n.gamma;
+}
+function Fe(t) {
+  for (const n of rn)
+    if (on(n.state, t)) return n;
+}
+const Pe = "rgba(255, 235, 59, 0.35)", Oe = 18, _e = 6, an = 32, cn = "#ff3b30", sn = 4;
+function ln() {
+  return {
+    color: cn,
+    strokeWidth: sn,
+    fillColor: null,
+    fontSize: an
+  };
+}
+function ze(t) {
+  return {
+    shapes: [],
+    selectedId: null,
+    activeTool: "select",
+    currentStyle: ln(),
+    imageSize: t.imageSize,
+    nextShapeNumber: 1
+  };
+}
+function De(t) {
+  return {
+    id: `s_${t.nextShapeNumber.toString(36)}`,
+    nextShapeNumber: t.nextShapeNumber + 1
+  };
+}
+function Le(t, n) {
+  return t.activeTool === n ? t : { ...t, activeTool: n, selectedId: n === "select" ? t.selectedId : null };
+}
+function Be(t, n) {
+  return { ...t, currentStyle: { ...t.currentStyle, ...n } };
+}
+function We(t, n) {
+  return t.selectedId === n ? t : { ...t, selectedId: n };
+}
+function Ye(t, n) {
+  return { ...t, shapes: [...t.shapes, n], selectedId: n.id };
+}
+function Xe(t, n) {
+  let e = !1;
+  const i = t.shapes.map((r) => r.id !== n.id ? r : (e = !0, n));
+  return e ? { ...t, shapes: i } : t;
+}
+function Ue(t, n) {
+  const e = t.shapes.filter((i) => i.id !== n);
+  return e.length === t.shapes.length ? t : {
+    ...t,
+    shapes: e,
+    selectedId: t.selectedId === n ? null : t.selectedId
+  };
+}
+function He(t, n) {
+  if (n !== null)
+    return t.shapes.find((e) => e.id === n);
+}
+function qe(t) {
+  let { x: n, y: e, width: i, height: r } = t;
+  return i < 0 && (n += i, i = -i), r < 0 && (e += r, r = -r), { x: n, y: e, width: i, height: r };
+}
+function je(t, n, e) {
+  switch (t.kind) {
+    case "text":
+      return { ...t, x: t.x + n, y: t.y + e };
+    case "rect":
+    case "ellipse":
+      return { ...t, x: t.x + n, y: t.y + e };
+    case "arrow":
+      return {
+        ...t,
+        x1: t.x1 + n,
+        y1: t.y1 + e,
+        x2: t.x2 + n,
+        y2: t.y2 + e
+      };
+    case "freehand":
+    case "highlight":
+      return { ...t, points: t.points.map((i) => ({ x: i.x + n, y: i.y + e })) };
+    default:
+      return w(t);
+  }
+}
+function w(t) {
+  throw new Error(`Unhandled annotation shape kind: ${JSON.stringify(t)}`);
+}
+function $e(t, n, e) {
+  if (n === "horizontal")
+    switch (t.kind) {
+      case "rect":
+      case "ellipse":
+        return { ...t, x: e.width - t.x - t.width };
+      case "text":
+        return { ...t, x: e.width - t.x };
+      case "arrow":
+        return { ...t, x1: e.width - t.x1, x2: e.width - t.x2 };
+      case "freehand":
+      case "highlight":
+        return {
+          ...t,
+          points: t.points.map((i) => ({ x: e.width - i.x, y: i.y }))
+        };
+      default:
+        return w(t);
+    }
+  switch (t.kind) {
+    case "rect":
+    case "ellipse":
+      return { ...t, y: e.height - t.y - t.height };
+    case "text":
+      return { ...t, y: e.height - t.y };
+    case "arrow":
+      return { ...t, y1: e.height - t.y1, y2: e.height - t.y2 };
+    case "freehand":
+    case "highlight":
+      return {
+        ...t,
+        points: t.points.map((i) => ({ x: i.x, y: e.height - i.y }))
+      };
+    default:
+      return w(t);
+  }
+}
+function Qe(t, n, e) {
+  if (n === 0) return t;
+  const i = (r, o) => n === 1 ? { x: e.height - o, y: r } : n === 2 ? { x: e.width - r, y: e.height - o } : { x: o, y: e.width - r };
+  switch (t.kind) {
+    case "rect":
+    case "ellipse": {
+      const r = [
+        i(t.x, t.y),
+        i(t.x + t.width, t.y + t.height)
+      ], o = Math.min(r[0].x, r[1].x), a = Math.min(r[0].y, r[1].y), c = Math.abs(r[1].x - r[0].x), l = Math.abs(r[1].y - r[0].y);
+      return { ...t, x: o, y: a, width: c, height: l };
+    }
+    case "text": {
+      const r = i(t.x, t.y);
+      return { ...t, x: r.x, y: r.y };
+    }
+    case "arrow": {
+      const r = i(t.x1, t.y1), o = i(t.x2, t.y2);
+      return { ...t, x1: r.x, y1: r.y, x2: o.x, y2: o.y };
+    }
+    case "freehand":
+    case "highlight":
+      return { ...t, points: t.points.map((r) => i(r.x, r.y)) };
+    default:
+      return w(t);
+  }
+}
+function Ke(t, n) {
+  return t.shapes.length === 0 ? t : { ...t, shapes: t.shapes.map(n) };
+}
+const Ve = [
+  "text",
+  "rect",
+  "ellipse",
+  "arrow"
+];
+function Ge(t) {
+  return t === "text" || t === "rect" || t === "ellipse" || t === "arrow";
+}
+function Je(t, n) {
+  const { imageSize: e, style: i, id: r } = n, o = Math.min(e.width, e.height), a = e.width / 2, c = e.height / 2;
+  switch (t) {
+    case "rect":
+    case "ellipse": {
+      const l = Math.max(80, Math.round(o * 0.25)), s = Math.round(a - l / 2), u = Math.round(c - l / 2);
+      return t === "rect" ? {
+        id: r,
+        kind: "rect",
+        x: s,
+        y: u,
+        width: l,
+        height: l,
+        strokeColor: i.color,
+        strokeWidth: i.strokeWidth,
+        fillColor: i.fillColor
+      } : {
+        id: r,
+        kind: "ellipse",
+        x: s,
+        y: u,
+        width: l,
+        height: l,
+        strokeColor: i.color,
+        strokeWidth: i.strokeWidth,
+        fillColor: i.fillColor
+      };
+    }
+    case "arrow": {
+      const l = Math.max(100, Math.round(o * 0.3)), s = Math.round(a - l / 2), u = s + l, h = Math.round(c);
+      return {
+        id: r,
+        kind: "arrow",
+        x1: s,
+        y1: h,
+        x2: u,
+        y2: h,
+        color: i.color,
+        strokeWidth: i.strokeWidth
+      };
+    }
+    case "text": {
+      const l = Math.round(a), s = Math.round(c - i.fontSize / 2);
+      return {
+        id: r,
+        kind: "text",
+        x: l,
+        y: s,
+        text: "",
+        fontSize: i.fontSize,
+        color: i.color,
+        textAlign: "center"
+      };
+    }
+  }
+}
+function nt(t) {
+  switch (t.kind) {
+    case "text": {
+      const { width: n, height: e } = un(t.text, t.fontSize);
+      return { x: hn(t.x, n, t.textAlign), y: t.y, width: n, height: e };
+    }
+    case "rect":
+    case "ellipse":
+      return { x: t.x, y: t.y, width: t.width, height: t.height };
+    case "arrow": {
+      const n = Math.min(t.x1, t.x2), e = Math.min(t.y1, t.y2);
+      return {
+        x: n,
+        y: e,
+        width: Math.abs(t.x2 - t.x1),
+        height: Math.abs(t.y2 - t.y1)
+      };
+    }
+    case "freehand":
+    case "highlight": {
+      const n = t.points[0];
+      if (!n) return { x: 0, y: 0, width: 0, height: 0 };
+      let e = n.x, i = n.y, r = n.x, o = n.y;
+      for (const a of t.points)
+        a.x < e && (e = a.x), a.x > r && (r = a.x), a.y < i && (i = a.y), a.y > o && (o = a.y);
+      return { x: e, y: i, width: r - e, height: o - i };
+    }
+    default:
+      return w(t);
+  }
+}
+const Ze = [
+  "tl",
+  "tr",
+  "bl",
+  "br",
+  "t",
+  "r",
+  "b",
+  "l"
+];
+function ti(t) {
+  const n = t.x, e = t.x + t.width, i = t.y, r = t.y + t.height, o = t.x + t.width / 2, a = t.y + t.height / 2;
+  return {
+    tl: { x: n, y: i },
+    tr: { x: e, y: i },
+    bl: { x: n, y: r },
+    br: { x: e, y: r },
+    t: { x: o, y: i },
+    r: { x: e, y: a },
+    b: { x: o, y: r },
+    l: { x: n, y: a }
+  };
+}
+function ni(t, n, e) {
+  let i = t.x, r = t.y, o = t.x + t.width, a = t.y + t.height;
+  return (n === "tl" || n === "l" || n === "bl") && (i = e.x), (n === "tr" || n === "r" || n === "br") && (o = e.x), (n === "tl" || n === "t" || n === "tr") && (r = e.y), (n === "bl" || n === "b" || n === "br") && (a = e.y), { x: i, y: r, width: o - i, height: a - r };
+}
+function un(t, n) {
+  const e = t.length === 0 ? [""] : t.split(`
+`);
+  let i = 0;
+  for (const a of e)
+    a.length > i && (i = a.length);
+  const r = Math.max(n * 0.6, i * n * 0.55), o = e.length * n * 1.2;
+  return { width: r, height: o };
+}
+function hn(t, n, e) {
+  switch (e) {
+    case "left":
+      return t;
+    case "center":
+      return t - n / 2;
+    case "right":
+      return t - n;
+  }
+}
+const x = 4;
+function ei(t, n) {
+  for (let e = t.length - 1; e >= 0; e--) {
+    const i = t[e];
+    if (i && fn(i, n)) return i;
+  }
+}
+function fn(t, n) {
+  switch (t.kind) {
+    case "text":
+      return S(n, nt(t));
+    case "rect": {
+      const e = S(n, I(t));
+      if (t.fillColor !== null) return e;
+      const i = N(I(t), t.strokeWidth / 2 + x), r = N(I(t), -(t.strokeWidth / 2 + x));
+      return S(n, i) && !S(n, r);
+    }
+    case "ellipse": {
+      const e = I(t), i = e.width / 2, r = e.height / 2, o = e.x + i, a = e.y + r;
+      if (i <= 0 || r <= 0) return !1;
+      const c = (n.x - o) / i, l = (n.y - a) / r, s = c * c + l * l, u = (t.strokeWidth / 2 + x) / Math.min(i, r);
+      return t.fillColor !== null ? s <= (1 + u) ** 2 : s <= (1 + u) ** 2 && s >= (1 - u) ** 2;
+    }
+    case "arrow":
+      return et(
+        n,
+        { x: t.x1, y: t.y1 },
+        { x: t.x2, y: t.y2 },
+        t.strokeWidth / 2 + x
+      );
+    case "freehand":
+    case "highlight": {
+      const e = nt(t), i = N(e, t.strokeWidth / 2 + x);
+      if (!S(n, i)) return !1;
+      const r = t.strokeWidth / 2 + x;
+      for (let o = 1; o < t.points.length; o++) {
+        const a = t.points[o - 1], c = t.points[o];
+        if (a && c && et(n, a, c, r)) return !0;
+      }
+      if (t.points.length === 1) {
+        const o = t.points[0];
+        if (!o) return !1;
+        const a = o.x - n.x, c = o.y - n.y;
+        return a * a + c * c <= r * r;
+      }
+      return !1;
+    }
+    default:
+      return w(t);
+  }
+}
+function S(t, n) {
+  return t.x >= n.x && t.y >= n.y && t.x <= n.x + n.width && t.y <= n.y + n.height;
+}
+function N(t, n) {
+  return {
+    x: t.x - n,
+    y: t.y - n,
+    width: t.width + n * 2,
+    height: t.height + n * 2
+  };
+}
+function I(t) {
+  let { x: n, y: e, width: i, height: r } = t;
+  return i < 0 && (n += i, i = -i), r < 0 && (e += r, r = -r), { x: n, y: e, width: i, height: r };
+}
+function et(t, n, e, i) {
+  const r = e.x - n.x, o = e.y - n.y, a = r * r + o * o;
+  if (a === 0) {
+    const f = t.x - n.x, d = t.y - n.y;
+    return f * f + d * d <= i * i;
+  }
+  let c = ((t.x - n.x) * r + (t.y - n.y) * o) / a;
+  c < 0 ? c = 0 : c > 1 && (c = 1);
+  const l = n.x + c * r, s = n.y + c * o, u = t.x - l, h = t.y - s;
+  return u * u + h * h <= i * i;
+}
+const it = 2;
+function ii(t) {
+  if (t.length <= 1) return [...t];
+  const n = t[0];
+  if (!n) return [];
+  const e = [n];
+  let i = n;
+  const r = it * it;
+  for (let a = 1; a < t.length - 1; a++) {
+    const c = t[a];
+    if (!c) continue;
+    const l = c.x - i.x, s = c.y - i.y;
+    l * l + s * s < r || (e.push(c), i = c);
+  }
+  const o = t[t.length - 1];
+  return o && o !== i && e.push(o), e;
+}
+function dt(t, n) {
+  if (n.length === 0) return;
+  const e = n[0];
+  if (!e) return;
+  if (n.length === 1) {
+    t.moveTo(e.x, e.y), t.lineTo(e.x, e.y);
+    return;
+  }
+  t.moveTo(e.x, e.y);
+  for (let r = 1; r < n.length - 1; r++) {
+    const o = n[r], a = n[r + 1];
+    if (!o || !a) continue;
+    const c = (o.x + a.x) / 2, l = (o.y + a.y) / 2;
+    t.quadraticCurveTo(o.x, o.y, c, l);
+  }
+  const i = n[n.length - 1];
+  i && t.lineTo(i.x, i.y);
+}
+const dn = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif';
+async function ri(t, n) {
+  if (t.shapes.length === 0) return n;
+  const e = g(n.width, n.height), i = y(e);
+  i.imageSmoothingEnabled = !0, i.imageSmoothingQuality = "high", i.drawImage(n.bitmap, 0, 0, n.width, n.height);
+  for (const r of t.shapes)
+    gn(i, r);
+  return {
+    bitmap: e.canvas,
+    width: n.width,
+    height: n.height,
+    mimeType: n.mimeType
+  };
+}
+function gn(t, n) {
+  switch (n.kind) {
+    case "text":
+      mn(t, n);
+      return;
+    case "rect":
+      yn(t, n);
+      return;
+    case "ellipse":
+      wn(t, n);
+      return;
+    case "arrow":
+      xn(t, n);
+      return;
+    case "freehand":
+      pn(t, n);
+      return;
+    case "highlight":
+      Mn(t, n);
+      return;
+    default:
+      w(n);
+  }
+}
+function mn(t, n) {
+  t.save(), t.fillStyle = n.color, t.font = `${n.fontSize}px ${dn}`, t.textAlign = n.textAlign, t.textBaseline = "top";
+  const e = n.text.length === 0 ? [""] : n.text.split(`
+`), i = n.fontSize * 1.2;
+  for (let r = 0; r < e.length; r++) {
+    const o = e[r];
+    o !== void 0 && t.fillText(o, n.x, n.y + r * i);
+  }
+  t.restore();
+}
+function yn(t, n) {
+  t.save(), n.fillColor !== null && (t.fillStyle = n.fillColor, t.fillRect(n.x, n.y, n.width, n.height)), n.strokeWidth > 0 && (t.strokeStyle = n.strokeColor, t.lineWidth = n.strokeWidth, t.lineJoin = "miter", t.strokeRect(n.x, n.y, n.width, n.height)), t.restore();
+}
+function wn(t, n) {
+  t.save();
+  const e = n.width / 2, i = n.height / 2, r = n.x + e, o = n.y + i;
+  t.beginPath(), t.ellipse(r, o, Math.max(0, e), Math.max(0, i), 0, 0, Math.PI * 2), n.fillColor !== null && (t.fillStyle = n.fillColor, t.fill()), n.strokeWidth > 0 && (t.strokeStyle = n.strokeColor, t.lineWidth = n.strokeWidth, t.stroke()), t.restore();
+}
+function xn(t, n) {
+  const e = n.x2 - n.x1, i = n.y2 - n.y1, r = Math.sqrt(e * e + i * i);
+  if (r < 0.5) return;
+  t.save(), t.strokeStyle = n.color, t.fillStyle = n.color, t.lineWidth = n.strokeWidth, t.lineCap = "round", t.lineJoin = "round";
+  const o = Math.min(Math.max(n.strokeWidth * 5, 28), r * 0.6), a = Math.max(n.strokeWidth * 4, 18), c = e / r, l = i / r, s = n.x2 - c * o * 0.6, u = n.y2 - l * o * 0.6;
+  t.beginPath(), t.moveTo(n.x1, n.y1), t.lineTo(s, u), t.stroke();
+  const h = n.x2 - c * o, f = n.y2 - l * o, d = -l, m = c;
+  t.beginPath(), t.moveTo(n.x2, n.y2), t.lineTo(h + d * a / 2, f + m * a / 2), t.lineTo(h - d * a / 2, f - m * a / 2), t.closePath(), t.fill(), t.restore();
+}
+function pn(t, n) {
+  n.points.length !== 0 && (t.save(), t.strokeStyle = n.color, t.lineWidth = n.strokeWidth, t.lineCap = "round", t.lineJoin = "round", t.beginPath(), dt(t, n.points), t.stroke(), t.restore());
+}
+function Mn(t, n) {
+  n.points.length !== 0 && (t.save(), t.globalCompositeOperation = "multiply", t.strokeStyle = n.color, t.lineWidth = n.strokeWidth, t.lineCap = "round", t.lineJoin = "round", t.beginPath(), dt(t, n.points), t.stroke(), t.restore());
+}
+const oi = ["pixelate", "blur", "solid"], Sn = "#000000", bn = "pixelate";
+function ai(t) {
+  return {
+    regions: [],
+    nextRegionNumber: 1,
+    selectedId: null,
+    currentMode: bn,
+    currentColor: Sn,
+    imageSize: t.imageSize
+  };
+}
+function ci(t) {
+  return {
+    id: `r_${t.nextRegionNumber.toString(36)}`,
+    nextRegionNumber: t.nextRegionNumber + 1
+  };
+}
+function si(t, n) {
+  return {
+    ...t,
+    regions: [...t.regions, n],
+    selectedId: n.id
+  };
+}
+function gt(t, n) {
+  let e = !1;
+  const i = t.regions.map((r) => r.id !== n.id ? r : (e = !0, n));
+  return e ? { ...t, regions: i } : t;
+}
+function li(t, n) {
+  const e = t.regions.filter((i) => i.id !== n);
+  return e.length === t.regions.length ? t : {
+    ...t,
+    regions: e,
+    selectedId: t.selectedId === n ? null : t.selectedId
+  };
+}
+function ui(t, n, e) {
+  if (t.regions.length === 0) return t;
+  const i = t.regions.map((r) => n === "horizontal" ? { ...r, x: e.width - r.x - r.width } : { ...r, y: e.height - r.y - r.height });
+  return { ...t, regions: i, imageSize: e };
+}
+function hi(t, n, e, i) {
+  if (t.regions.length === 0) return { ...t, imageSize: i };
+  if (n === 0 && e === 0 && t.imageSize === i) return t;
+  const r = t.regions.map((o) => ({
+    ...o,
+    x: o.x + n,
+    y: o.y + e
+  }));
+  return { ...t, regions: r, imageSize: i };
+}
+function fi(t, n, e) {
+  if (n === 0) return { ...t, imageSize: e };
+  if (t.regions.length === 0) return { ...t, imageSize: e };
+  const i = t.imageSize.width, r = t.imageSize.height, o = t.regions.map((a) => {
+    const { x: c, y: l, width: s, height: u } = a;
+    return n === 1 ? { ...a, x: r - l - u, y: c, width: u, height: s } : n === 2 ? {
+      ...a,
+      x: i - c - s,
+      y: r - l - u
+    } : { ...a, x: l, y: i - c - s, width: u, height: s };
+  });
+  return { ...t, regions: o, imageSize: e };
+}
+function di(t, n) {
+  return t.selectedId === n ? t : { ...t, selectedId: n };
+}
+function gi(t, n) {
+  return t.currentMode === n ? t : { ...t, currentMode: n };
+}
+function mi(t, n) {
+  return t.currentColor === n ? t : { ...t, currentColor: n };
+}
+function yi(t, n, e) {
+  const i = t.regions.find((r) => r.id === n);
+  return !i || i.mode === e ? t : gt(t, { ...i, mode: e });
+}
+function wi(t, n, e) {
+  const i = t.regions.find((r) => r.id === n);
+  return !i || i.color === e ? t : gt(t, { ...i, color: e });
+}
+function xi(t, n) {
+  if (n !== null)
+    return t.regions.find((e) => e.id === n);
+}
+function pi(t) {
+  return t.selectedId === null ? null : t.regions.find((n) => n.id === t.selectedId) ?? null;
+}
+function Mi(t) {
+  let { x: n, y: e, width: i, height: r } = t;
+  return i < 0 && (n += i, i = -i), r < 0 && (e += r, r = -r), { x: n, y: e, width: i, height: r };
+}
+function Si(t) {
+  const { imageSize: n, mode: e, color: i, id: r } = t, o = Math.min(n.width, n.height), a = Math.max(80, Math.round(o * 0.25)), c = n.width / 2, l = n.height / 2, s = Math.round(c - a / 2), u = Math.round(l - a / 2);
+  return {
+    id: r,
+    x: s,
+    y: u,
+    width: a,
+    height: a,
+    mode: e,
+    color: i
+  };
+}
+function bi(t, n) {
+  if (t.imageSize.width === n.width && t.imageSize.height === n.height)
+    return t;
+  const e = [];
+  for (const r of t.regions)
+    r.x + r.width <= 0 || r.y + r.height <= 0 || r.x >= n.width || r.y >= n.height || e.push(En(r, n));
+  const i = t.selectedId !== null && !e.some((r) => r.id === t.selectedId);
+  return {
+    ...t,
+    regions: e,
+    imageSize: { width: n.width, height: n.height },
+    selectedId: i ? null : t.selectedId
+  };
+}
+function En(t, n) {
+  const e = Math.max(0, t.x), i = Math.max(0, t.y), r = Math.min(n.width, t.x + t.width), o = Math.min(n.height, t.y + t.height);
+  return {
+    ...t,
+    x: e,
+    y: i,
+    width: Math.max(0, r - e),
+    height: Math.max(0, o - i)
+  };
+}
+function Ei(t) {
+  return { x: t.x, y: t.y, width: t.width, height: t.height };
+}
+async function Ri(t, n) {
+  if (t.regions.length === 0) return n;
+  const e = g(n.width, n.height), i = y(e);
+  i.drawImage(n.bitmap, 0, 0, n.width, n.height);
+  for (const r of t.regions)
+    Rn(i, e.canvas, r, n);
+  return {
+    bitmap: e.canvas,
+    width: n.width,
+    height: n.height,
+    mimeType: n.mimeType
+  };
+}
+function Rn(t, n, e, i) {
+  const r = Math.round(e.width), o = Math.round(e.height);
+  if (r < 1 || o < 1) return;
+  const a = Math.round(e.x), c = Math.round(e.y);
+  switch (e.mode) {
+    case "solid":
+      In(t, e, a, c, r, o);
+      return;
+    case "pixelate":
+      Tn(t, n, i, a, c, r, o);
+      return;
+    case "blur":
+      kn(t, n, i, a, c, r, o);
+      return;
+  }
+}
+function In(t, n, e, i, r, o) {
+  t.save(), t.fillStyle = n.color, t.fillRect(e, i, r, o), t.restore();
+}
+function Tn(t, n, e, i, r, o, a) {
+  const c = Math.max(o, a), l = Math.max(4, Math.round(8 * Math.min(1, c / 240))), s = Math.max(1, Math.round(o / c * l)), u = Math.max(1, Math.round(a / c * l));
+  t.save();
+  const h = F(s, u);
+  if (!h) {
+    t.restore();
+    return;
+  }
+  h.ctx.imageSmoothingEnabled = !0, h.ctx.imageSmoothingQuality = "low", h.ctx.drawImage(n, i, r, o, a, 0, 0, s, u), t.imageSmoothingEnabled = !1, t.drawImage(h.canvas, 0, 0, s, u, i, r, o, a), t.restore();
+}
+function kn(t, n, e, i, r, o, a) {
+  const l = Math.max(1, Math.round(o * 0.125)), s = Math.max(1, Math.round(a * 0.125)), u = F(l, s);
+  if (!u) return;
+  u.ctx.imageSmoothingEnabled = !0, u.ctx.imageSmoothingQuality = "high", u.ctx.drawImage(n, i, r, o, a, 0, 0, l, s);
+  const h = Math.max(1, Math.round(l * 0.5)), f = Math.max(1, Math.round(s * 0.5)), d = F(h, f);
+  if (!d) {
+    t.save(), t.imageSmoothingEnabled = !0, t.imageSmoothingQuality = "high", t.drawImage(u.canvas, 0, 0, l, s, i, r, o, a), t.restore();
+    return;
+  }
+  d.ctx.imageSmoothingEnabled = !0, d.ctx.imageSmoothingQuality = "high", d.ctx.drawImage(u.canvas, 0, 0, l, s, 0, 0, h, f), t.save(), t.imageSmoothingEnabled = !0, t.imageSmoothingQuality = "high", t.drawImage(d.canvas, 0, 0, h, f, i, r, o, a), t.restore();
+}
+function F(t, n) {
+  if (typeof OffscreenCanvas < "u")
+    try {
+      const r = new OffscreenCanvas(t, n), o = r.getContext("2d");
+      if (o) return { canvas: r, ctx: o };
+    } catch {
+    }
+  if (typeof document > "u") return null;
+  const e = document.createElement("canvas");
+  e.width = t, e.height = n;
+  const i = e.getContext("2d");
+  return i ? { canvas: e, ctx: i } : null;
+}
+const Ii = [
+  "none",
+  "solidSharp",
+  "solidRound",
+  "lineSingle",
+  "hook",
+  "polaroid"
+], Cn = [
+  {
+    id: "none",
+    label: "None",
+    acceptsColor: !1,
+    defaultColor: "#000000"
+  },
+  {
+    id: "solidSharp",
+    label: "Mat Sharp",
+    acceptsColor: !0,
+    defaultColor: "#000000"
+  },
+  {
+    id: "solidRound",
+    label: "Mat Round",
+    acceptsColor: !0,
+    defaultColor: "#000000"
+  },
+  {
+    id: "lineSingle",
+    label: "Line Single",
+    acceptsColor: !0,
+    defaultColor: "#000000"
+  },
+  {
+    id: "hook",
+    label: "Corner Hooks",
+    acceptsColor: !0,
+    defaultColor: "#000000"
+  },
+  {
+    id: "polaroid",
+    label: "Polaroid",
+    acceptsColor: !0,
+    defaultColor: "#ffffff"
+  }
+], vn = {
+  presetId: "none",
+  color: "#000000"
+};
+function Ti() {
+  return vn;
+}
+function An(t) {
+  return t.presetId === "none";
+}
+function ki(t, n) {
+  if (t.presetId === n) return t;
+  const e = rt(t.presetId), i = rt(n);
+  if (!i) return { ...t, presetId: n };
+  const o = e !== void 0 && t.color === e.defaultColor ? i.defaultColor : t.color;
+  return { presetId: n, color: o };
+}
+function Ci(t, n) {
+  return t.color === n ? t : { ...t, color: n };
+}
+function rt(t) {
+  return Cn.find((n) => n.id === t);
+}
+async function vi(t, n) {
+  return An(t) ? n : t.presetId === "polaroid" ? zn(t.color, n) : t.presetId === "none" ? n : Nn(t.presetId, t.color, n);
+}
+function Nn(t, n, e) {
+  const i = g(e.width, e.height), r = y(i);
+  return r.drawImage(e.bitmap, 0, 0, e.width, e.height), Fn(r, t, n, e.width, e.height), {
+    bitmap: i.canvas,
+    width: e.width,
+    height: e.height,
+    mimeType: e.mimeType
+  };
+}
+function Fn(t, n, e, i, r) {
+  switch (n) {
+    case "solidSharp":
+      mt(t, e, i, r);
+      return;
+    case "solidRound":
+      Pn(t, e, i, r);
+      return;
+    case "lineSingle":
+      On(t, e, i, r);
+      return;
+    case "hook":
+      _n(t, e, i, r);
+      return;
+  }
+}
+function mt(t, n, e, i) {
+  const r = yt(e, i);
+  t.save(), t.fillStyle = n, t.fillRect(0, 0, e, r), t.fillRect(0, i - r, e, r), t.fillRect(0, r, r, i - 2 * r), t.fillRect(e - r, r, r, i - 2 * r), t.restore();
+}
+function Pn(t, n, e, i) {
+  const o = yt(e, i);
+  mt(t, n, e, i), t.save(), t.globalCompositeOperation = "destination-out", t.fillStyle = "#000", T(t, 0, 0, o, "tl"), T(t, e, 0, o, "tr"), T(t, 0, i, o, "bl"), T(t, e, i, o, "br"), t.restore();
+}
+function T(t, n, e, i, r) {
+  switch (t.beginPath(), t.moveTo(n, e), r) {
+    case "tl":
+      t.lineTo(n + i, e), t.arc(n + i, e + i, i, -Math.PI / 2, Math.PI, !0), t.lineTo(n, e);
+      break;
+    case "tr":
+      t.lineTo(n, e + i), t.arc(n - i, e + i, i, 0, -Math.PI / 2, !0), t.lineTo(n, e);
+      break;
+    case "bl":
+      t.lineTo(n + i, e), t.arc(n + i, e - i, i, Math.PI / 2, Math.PI, !1), t.lineTo(n, e);
+      break;
+    case "br":
+      t.lineTo(n - i, e), t.arc(n - i, e - i, i, Math.PI / 2, 0, !0), t.lineTo(n, e);
+      break;
+  }
+  t.closePath(), t.fill();
+}
+function On(t, n, e, i) {
+  const r = Math.round(Math.min(e, i) * 0.05), o = Math.max(2, Math.round(Math.min(e, i) * 0.01));
+  t.save(), t.strokeStyle = n, t.lineWidth = o;
+  const a = o / 2;
+  t.strokeRect(
+    r + a,
+    r + a,
+    e - 2 * r - o,
+    i - 2 * r - o
+  ), t.restore();
+}
+function _n(t, n, e, i) {
+  const r = Math.round(Math.min(e, i) * 0.08), o = Math.max(2, Math.round(Math.min(e, i) * 0.01)), a = Math.round(Math.min(e, i) * 0.05);
+  t.save(), t.strokeStyle = n, t.lineWidth = o, t.lineCap = "square";
+  const c = o / 2, l = (s, u, h, f) => {
+    t.beginPath(), t.moveTo(s + h * r, u), t.lineTo(s, u), t.lineTo(s, u + f * r), t.stroke();
+  };
+  l(a + c, a + c, 1, 1), l(e - a - c, a + c, -1, 1), l(a + c, i - a - c, 1, -1), l(e - a - c, i - a - c, -1, -1), t.restore();
+}
+function zn(t, n) {
+  const e = Math.min(n.width, n.height), i = Math.round(e * 0.05), r = i, o = i, a = Math.round(e * 0.18), c = n.width + r + o, l = n.height + i + a, s = g(c, l), u = y(s);
+  return u.fillStyle = t, u.fillRect(0, 0, c, l), u.drawImage(n.bitmap, r, i, n.width, n.height), {
+    bitmap: s.canvas,
+    width: c,
+    height: l,
+    mimeType: n.mimeType
+  };
+}
+function yt(t, n) {
+  return Math.max(4, Math.round(Math.min(t, n) * 0.04));
+}
+function Ai(t, n, e) {
+  if (t !== "polaroid")
+    return { width: n, height: e };
+  const i = Math.min(n, e), r = Math.round(i * 0.05), o = Math.round(i * 0.18);
+  return {
+    width: n + 2 * r,
+    height: e + r + o
+  };
+}
+export {
+  Ze as ALL_SELECTION_HANDLES,
+  _ as DEFAULT_FINETUNE_STATE,
+  vn as DEFAULT_FRAME_STATE,
+  ut as DEFAULT_OUTPUT_STATE,
+  cn as DEFAULT_PALETTE_COLOR,
+  Sn as DEFAULT_REDACT_COLOR,
+  bn as DEFAULT_REDACT_MODE,
+  sn as DEFAULT_STROKE_WIDTH,
+  re as ENCODABLE_MIMES,
+  Dn as EventBus,
+  rn as FILTER_PRESETS,
+  Te as FINETUNE_ADJUSTMENTS,
+  J as FINETUNE_MAX,
+  G as FINETUNE_MIN,
+  Z as FINETUNE_STEP,
+  Cn as FRAME_PRESETS,
+  Ii as FRAME_PRESET_IDS,
+  _e as FREEHAND_DEFAULT_STROKE,
+  Yt as FREE_ANGLE_MAX,
+  Wt as FREE_ANGLE_MIN,
+  de as FREE_ANGLE_STEP,
+  Pe as HIGHLIGHT_DEFAULT_COLOR,
+  Oe as HIGHLIGHT_DEFAULT_STROKE,
+  W as HISTORY_MAX_ENTRIES,
+  Jn as History,
+  k as IDENTITY_VIEWPORT_TRANSFORM,
+  Ve as KEYBOARD_PLACEABLE_KINDS,
+  ot as MAX_ZOOM,
+  it as MIN_SAMPLE_DISTANCE,
+  at as MIN_ZOOM,
+  x as PICK_TOLERANCE,
+  oi as REDACT_MODES,
+  ft as RESIZE_MAX_DIMENSION,
+  K as RESIZE_MIN_DIMENSION,
+  dn as SYSTEM_FONT_STACK,
+  an as TEXT_DEFAULT_FONT_SIZE,
+  Un as ViewportController,
+  si as addRegion,
+  Ye as addShape,
+  hn as alignToOrigin,
+  Et as applyAspectRatio,
+  nn as applyClarity,
+  tn as applyFinetuneLutAndSaturation,
+  tt as applyFinetuneToImageData,
+  ee as applyPresetByIndex,
+  w as assertNever,
+  ri as bakeAnnotate,
+  st as bakeCanvasToBlob,
+  ie as bakeCrop,
+  Ne as bakeFinetune,
+  fe as bakeFlip,
+  vi as bakeFrame,
+  Ri as bakeRedact,
+  Ie as bakeResize,
+  xe as bakeRotate,
+  nt as boundingBoxOf,
+  en as boxBlur3x3,
+  Jt as buildFinetuneLut,
+  b as canEncodeMime,
+  ht as clampQuality,
+  P as clampRectInside,
+  pt as computeViewport,
+  vt as copyJpegExif,
+  g as createBakeCanvas,
+  Si as createCenteredRedactRegion,
+  Je as createCenteredShape,
+  Gn as createStore,
+  ii as decimatePoints,
+  ln as defaultStylePalette,
+  li as deleteRedactRegion,
+  Ue as deleteShape,
+  Ot as deriveOutputName,
+  Ut as effectiveAngleDeg,
+  Re as effectivePercent,
+  se as encodeSourceImage,
+  un as estimateTextSize,
+  te as filterPresets,
+  Fe as findActivePreset,
+  rt as findFramePreset,
+  xi as findRedactRegion,
+  He as findShape,
+  on as finetuneStatesEqual,
+  O as fitRectToBoundsWithRatio,
+  Ai as frameOutputSize,
+  y as getBakeContext2D,
+  fn as hitTest,
+  ze as initialAnnotateState,
+  ne as initialCropState,
+  ke as initialFinetuneState,
+  ue as initialFlipState,
+  Ti as initialFrameState,
+  ai as initialRedactState,
+  pe as initialResizeState,
+  ge as initialRotateState,
+  Vt as isFinetuneNoOp,
+  Bt as isFlipNoOp,
+  An as isFrameNoOp,
+  Ge as isKeyboardPlaceableKind,
+  kt as isPresetVisible,
+  jt as isResizeNoOp,
+  Xt as isRotateNoOp,
+  qt as largestInscribedRect,
+  Ln as loadImage,
+  ci as mintRegionId,
+  De as mintShapeId,
+  ui as mirrorRedactRegions,
+  $e as mirrorShape,
+  qe as normaliseRectExtent,
+  Mi as normaliseRedactExtent,
+  Fn as paintInsideFrame,
+  Rn as paintRedactRegion,
+  gn as paintShape,
+  ei as pickShape,
+  Wn as pointDisplayToImage,
+  Bn as pointImageToDisplay,
+  Qn as pointInRect,
+  jn as rectBottom,
+  $n as rectCenter,
+  Xn as rectDisplayToImage,
+  ni as rectFromHandleDrag,
+  Hn as rectFromPoints,
+  Yn as rectImageToDisplay,
+  qn as rectRight,
+  Kn as rectsEqual,
+  Ei as regionBoundingBox,
+  gt as replaceRedactRegion,
+  Xe as replaceShape,
+  Ae as resetAllFinetune,
+  ve as resetFinetune,
+  Zn as resizeRectFromHandle,
+  Pt as resolveOutputMime,
+  $t as resolveOutputSize,
+  bi as revalidateRedactAgainstBounds,
+  me as rotateClockwise,
+  ye as rotateCounterClockwise,
+  fi as rotateRedactRegions,
+  Qe as rotateShape,
+  St as roundRect,
+  le as runUtilityChain,
+  di as selectRedactRegion,
+  We as selectShape,
+  pi as selectedRedactRegionOf,
+  ti as selectionHandlePositions,
+  Le as setActiveTool,
+  Ce as setFinetune,
+  Ci as setFrameColor,
+  ki as setFramePreset,
+  we as setFreeAngle,
+  Se as setHeightPx,
+  Ee as setLockAspect,
+  oe as setOutputMime,
+  ae as setOutputQuality,
+  be as setPercent,
+  mi as setRedactCurrentColor,
+  gi as setRedactCurrentMode,
+  wi as setRedactRegionColor,
+  yi as setRedactRegionMode,
+  ce as setStripMetadata,
+  Be as setStyle,
+  Me as setWidthPx,
+  he as toggleFlip,
+  dt as tracePath,
+  Ke as transformShapes,
+  Vn as translateClampedRect,
+  hi as translateRedactRegions,
+  je as translateShape
+};
+//# sourceMappingURL=index.js.map