@annotorious/react 3.4.3 → 3.4.5

package/dist/annotorious-react.es23.js

@@ -1,473 +1,129 @@
-import { evaluate as X, rectToClientRect as I, getPaddingObject as W, getSide as Y, getSideAxis as F, getOppositePlacement as U, getExpandedPlacements as Z, getOppositeAxisPlacements as tt, getAlignmentSides as et, clamp as z, min as $, max as H, getAlignment as _, getOppositeAxis as nt, getAlignmentAxis as G, getAxisLength as J } from "./annotorious-react.es22.js";
-function q(o, c, l) {
-  let {
-    reference: e,
-    floating: s
-  } = o;
-  const t = F(c), a = G(c), r = J(a), d = Y(c), g = t === "y", u = e.x + e.width / 2 - s.width / 2, n = e.y + e.height / 2 - s.height / 2, m = e[r] / 2 - s[r] / 2;
-  let i;
-  switch (d) {
+const l = Math.min, a = Math.max, P = Math.round, M = Math.floor, O = (t) => ({
+  x: t,
+  y: t
+}), m = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, p = {
+  start: "end",
+  end: "start"
+};
+function S(t, n, e) {
+  return a(t, l(n, e));
+}
+function w(t, n) {
+  return typeof t == "function" ? t(n) : t;
+}
+function f(t) {
+  return t.split("-")[0];
+}
+function g(t) {
+  return t.split("-")[1];
+}
+function h(t) {
+  return t === "x" ? "y" : "x";
+}
+function x(t) {
+  return t === "y" ? "height" : "width";
+}
+function b(t) {
+  return ["top", "bottom"].includes(f(t)) ? "y" : "x";
+}
+function d(t) {
+  return h(b(t));
+}
+function j(t, n, e) {
+  e === void 0 && (e = !1);
+  const r = g(t), o = d(t), i = x(o);
+  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return n.reference[i] > n.floating[i] && (c = u(c)), [c, u(c)];
+}
+function C(t) {
+  const n = u(t);
+  return [s(t), n, s(n)];
+}
+function s(t) {
+  return t.replace(/start|end/g, (n) => p[n]);
+}
+function A(t, n, e) {
+  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
+  switch (t) {
     case "top":
-      i = {
-        x: u,
-        y: e.y - s.height
-      };
-      break;
     case "bottom":
-      i = {
-        x: u,
-        y: e.y + e.height
-      };
-      break;
-    case "right":
-      i = {
-        x: e.x + e.width,
-        y: n
-      };
-      break;
+      return e ? n ? o : r : n ? r : o;
     case "left":
-      i = {
-        x: e.x - s.width,
-        y: n
-      };
-      break;
+    case "right":
+      return n ? i : c;
     default:
-      i = {
-        x: e.x,
-        y: e.y
-      };
+      return [];
   }
-  switch (_(c)) {
-    case "start":
-      i[a] -= m * (l && g ? -1 : 1);
-      break;
-    case "end":
-      i[a] += m * (l && g ? -1 : 1);
-      break;
-  }
-  return i;
 }
-const ct = async (o, c, l) => {
-  const {
-    placement: e = "bottom",
-    strategy: s = "absolute",
-    middleware: t = [],
-    platform: a
-  } = l, r = t.filter(Boolean), d = await (a.isRTL == null ? void 0 : a.isRTL(c));
-  let g = await a.getElementRects({
-    reference: o,
-    floating: c,
-    strategy: s
-  }), {
-    x: u,
-    y: n
-  } = q(g, e, d), m = e, i = {}, f = 0;
-  for (let h = 0; h < r.length; h++) {
-    const {
-      name: x,
-      fn: y
-    } = r[h], {
-      x: v,
-      y: A,
-      data: b,
-      reset: p
-    } = await y({
-      x: u,
-      y: n,
-      initialPlacement: e,
-      placement: m,
-      strategy: s,
-      middlewareData: i,
-      rects: g,
-      platform: a,
-      elements: {
-        reference: o,
-        floating: c
-      }
-    });
-    u = v ?? u, n = A ?? n, i = {
-      ...i,
-      [x]: {
-        ...i[x],
-        ...b
-      }
-    }, p && f <= 50 && (f++, typeof p == "object" && (p.placement && (m = p.placement), p.rects && (g = p.rects === !0 ? await a.getElementRects({
-      reference: o,
-      floating: c,
-      strategy: s
-    }) : p.rects), {
-      x: u,
-      y: n
-    } = q(g, m, d)), h = -1);
-  }
-  return {
-    x: u,
-    y: n,
-    placement: m,
-    strategy: s,
-    middlewareData: i
-  };
-};
-async function K(o, c) {
-  var l;
-  c === void 0 && (c = {});
-  const {
-    x: e,
-    y: s,
-    platform: t,
-    rects: a,
-    elements: r,
-    strategy: d
-  } = o, {
-    boundary: g = "clippingAncestors",
-    rootBoundary: u = "viewport",
-    elementContext: n = "floating",
-    altBoundary: m = !1,
-    padding: i = 0
-  } = X(c, o), f = W(i), x = r[m ? n === "floating" ? "reference" : "floating" : n], y = I(await t.getClippingRect({
-    element: (l = await (t.isElement == null ? void 0 : t.isElement(x))) == null || l ? x : x.contextElement || await (t.getDocumentElement == null ? void 0 : t.getDocumentElement(r.floating)),
-    boundary: g,
-    rootBoundary: u,
-    strategy: d
-  })), v = n === "floating" ? {
-    x: e,
-    y: s,
-    width: a.floating.width,
-    height: a.floating.height
-  } : a.reference, A = await (t.getOffsetParent == null ? void 0 : t.getOffsetParent(r.floating)), b = await (t.isElement == null ? void 0 : t.isElement(A)) ? await (t.getScale == null ? void 0 : t.getScale(A)) || {
-    x: 1,
-    y: 1
-  } : {
-    x: 1,
-    y: 1
-  }, p = I(t.convertOffsetParentRelativeRectToViewportRelativeRect ? await t.convertOffsetParentRelativeRectToViewportRelativeRect({
-    elements: r,
-    rect: v,
-    offsetParent: A,
-    strategy: d
-  }) : v);
-  return {
-    top: (y.top - p.top + f.top) / b.y,
-    bottom: (p.bottom - y.bottom + f.bottom) / b.y,
-    left: (y.left - p.left + f.left) / b.x,
-    right: (p.right - y.right + f.right) / b.x
-  };
+function L(t, n, e, r) {
+  const o = g(t);
+  let i = A(f(t), e === "start", r);
+  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
 }
-const lt = (o) => ({
-  name: "arrow",
-  options: o,
-  async fn(c) {
-    const {
-      x: l,
-      y: e,
-      placement: s,
-      rects: t,
-      platform: a,
-      elements: r,
-      middlewareData: d
-    } = c, {
-      element: g,
-      padding: u = 0
-    } = X(o, c) || {};
-    if (g == null)
-      return {};
-    const n = W(u), m = {
-      x: l,
-      y: e
-    }, i = G(s), f = J(i), h = await a.getDimensions(g), x = i === "y", y = x ? "top" : "left", v = x ? "bottom" : "right", A = x ? "clientHeight" : "clientWidth", b = t.reference[f] + t.reference[i] - m[i] - t.floating[f], p = m[i] - t.reference[i], C = await (a.getOffsetParent == null ? void 0 : a.getOffsetParent(g));
-    let k = C ? C[A] : 0;
-    (!k || !await (a.isElement == null ? void 0 : a.isElement(C))) && (k = r.floating[A] || t.floating[f]);
-    const j = b / 2 - p / 2, L = k / 2 - h[f] / 2 - 1, w = $(n[y], L), B = $(n[v], L), S = w, M = k - h[f] - B, P = k / 2 - h[f] / 2 + j, R = z(S, P, M), E = !d.arrow && _(s) != null && P !== R && t.reference[f] / 2 - (P < S ? w : B) - h[f] / 2 < 0, O = E ? P < S ? P - S : P - M : 0;
-    return {
-      [i]: m[i] + O,
-      data: {
-        [i]: R,
-        centerOffset: P - R - O,
-        ...E && {
-          alignmentOffset: O
-        }
-      },
-      reset: E
-    };
-  }
-}), at = function(o) {
-  return o === void 0 && (o = {}), {
-    name: "flip",
-    options: o,
-    async fn(c) {
-      var l, e;
-      const {
-        placement: s,
-        middlewareData: t,
-        rects: a,
-        initialPlacement: r,
-        platform: d,
-        elements: g
-      } = c, {
-        mainAxis: u = !0,
-        crossAxis: n = !0,
-        fallbackPlacements: m,
-        fallbackStrategy: i = "bestFit",
-        fallbackAxisSideDirection: f = "none",
-        flipAlignment: h = !0,
-        ...x
-      } = X(o, c);
-      if ((l = t.arrow) != null && l.alignmentOffset)
-        return {};
-      const y = Y(s), v = F(r), A = Y(r) === r, b = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), p = m || (A || !h ? [U(r)] : Z(r)), C = f !== "none";
-      !m && C && p.push(...tt(r, h, f, b));
-      const k = [r, ...p], j = await K(c, x), L = [];
-      let w = ((e = t.flip) == null ? void 0 : e.overflows) || [];
-      if (u && L.push(j[y]), n) {
-        const R = et(s, a, b);
-        L.push(j[R[0]], j[R[1]]);
-      }
-      if (w = [...w, {
-        placement: s,
-        overflows: L
-      }], !L.every((R) => R <= 0)) {
-        var B, S;
-        const R = (((B = t.flip) == null ? void 0 : B.index) || 0) + 1, E = k[R];
-        if (E) {
-          var M;
-          const D = n === "alignment" ? v !== F(E) : !1, T = ((M = w[0]) == null ? void 0 : M.overflows[0]) > 0;
-          if (!D || T)
-            return {
-              data: {
-                index: R,
-                overflows: w
-              },
-              reset: {
-                placement: E
-              }
-            };
-        }
-        let O = (S = w.filter((D) => D.overflows[0] <= 0).sort((D, T) => D.overflows[1] - T.overflows[1])[0]) == null ? void 0 : S.placement;
-        if (!O)
-          switch (i) {
-            case "bestFit": {
-              var P;
-              const D = (P = w.filter((T) => {
-                if (C) {
-                  const V = F(T.placement);
-                  return V === v || // Create a bias to the `y` side axis due to horizontal
-                  // reading directions favoring greater width.
-                  V === "y";
-                }
-                return !0;
-              }).map((T) => [T.placement, T.overflows.filter((V) => V > 0).reduce((V, Q) => V + Q, 0)]).sort((T, V) => T[1] - V[1])[0]) == null ? void 0 : P[0];
-              D && (O = D);
-              break;
-            }
-            case "initialPlacement":
-              O = r;
-              break;
-          }
-        if (s !== O)
-          return {
-            reset: {
-              placement: O
-            }
-          };
-      }
-      return {};
-    }
-  };
-};
-function N(o) {
-  const c = $(...o.map((t) => t.left)), l = $(...o.map((t) => t.top)), e = H(...o.map((t) => t.right)), s = H(...o.map((t) => t.bottom));
+function u(t) {
+  return t.replace(/left|right|bottom|top/g, (n) => m[n]);
+}
+function y(t) {
   return {
-    x: c,
-    y: l,
-    width: e - c,
-    height: s - l
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
   };
 }
-function it(o) {
-  const c = o.slice().sort((s, t) => s.y - t.y), l = [];
-  let e = null;
-  for (let s = 0; s < c.length; s++) {
-    const t = c[s];
-    !e || t.y - e.y > e.height / 2 ? l.push([t]) : l[l.length - 1].push(t), e = t;
-  }
-  return l.map((s) => I(N(s)));
-}
-const rt = function(o) {
-  return o === void 0 && (o = {}), {
-    name: "inline",
-    options: o,
-    async fn(c) {
-      const {
-        placement: l,
-        elements: e,
-        rects: s,
-        platform: t,
-        strategy: a
-      } = c, {
-        padding: r = 2,
-        x: d,
-        y: g
-      } = X(o, c), u = Array.from(await (t.getClientRects == null ? void 0 : t.getClientRects(e.reference)) || []), n = it(u), m = I(N(u)), i = W(r);
-      function f() {
-        if (n.length === 2 && n[0].left > n[1].right && d != null && g != null)
-          return n.find((x) => d > x.left - i.left && d < x.right + i.right && g > x.top - i.top && g < x.bottom + i.bottom) || m;
-        if (n.length >= 2) {
-          if (F(l) === "y") {
-            const w = n[0], B = n[n.length - 1], S = Y(l) === "top", M = w.top, P = B.bottom, R = S ? w.left : B.left, E = S ? w.right : B.right, O = E - R, D = P - M;
-            return {
-              top: M,
-              bottom: P,
-              left: R,
-              right: E,
-              width: O,
-              height: D,
-              x: R,
-              y: M
-            };
-          }
-          const x = Y(l) === "left", y = H(...n.map((w) => w.right)), v = $(...n.map((w) => w.left)), A = n.filter((w) => x ? w.left === v : w.right === y), b = A[0].top, p = A[A.length - 1].bottom, C = v, k = y, j = k - C, L = p - b;
-          return {
-            top: b,
-            bottom: p,
-            left: C,
-            right: k,
-            width: j,
-            height: L,
-            x: C,
-            y: b
-          };
-        }
-        return m;
-      }
-      const h = await t.getElementRects({
-        reference: {
-          getBoundingClientRect: f
-        },
-        floating: e.floating,
-        strategy: a
-      });
-      return s.reference.x !== h.reference.x || s.reference.y !== h.reference.y || s.reference.width !== h.reference.width || s.reference.height !== h.reference.height ? {
-        reset: {
-          rects: h
-        }
-      } : {};
-    }
+function E(t) {
+  return typeof t != "number" ? y(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
   };
-};
-async function ot(o, c) {
+}
+function R(t) {
   const {
-    placement: l,
-    platform: e,
-    elements: s
-  } = o, t = await (e.isRTL == null ? void 0 : e.isRTL(s.floating)), a = Y(l), r = _(l), d = F(l) === "y", g = ["left", "top"].includes(a) ? -1 : 1, u = t && d ? -1 : 1, n = X(c, o);
-  let {
-    mainAxis: m,
-    crossAxis: i,
-    alignmentAxis: f
-  } = typeof n == "number" ? {
-    mainAxis: n,
-    crossAxis: 0,
-    alignmentAxis: null
-  } : {
-    mainAxis: n.mainAxis || 0,
-    crossAxis: n.crossAxis || 0,
-    alignmentAxis: n.alignmentAxis
-  };
-  return r && typeof f == "number" && (i = r === "end" ? f * -1 : f), d ? {
-    x: i * u,
-    y: m * g
-  } : {
-    x: m * g,
-    y: i * u
+    x: n,
+    y: e,
+    width: r,
+    height: o
+  } = t;
+  return {
+    width: r,
+    height: o,
+    top: e,
+    left: n,
+    right: n + r,
+    bottom: e + o,
+    x: n,
+    y: e
   };
 }
-const ft = function(o) {
-  return o === void 0 && (o = 0), {
-    name: "offset",
-    options: o,
-    async fn(c) {
-      var l, e;
-      const {
-        x: s,
-        y: t,
-        placement: a,
-        middlewareData: r
-      } = c, d = await ot(c, o);
-      return a === ((l = r.offset) == null ? void 0 : l.placement) && (e = r.arrow) != null && e.alignmentOffset ? {} : {
-        x: s + d.x,
-        y: t + d.y,
-        data: {
-          ...d,
-          placement: a
-        }
-      };
-    }
-  };
-}, mt = function(o) {
-  return o === void 0 && (o = {}), {
-    name: "shift",
-    options: o,
-    async fn(c) {
-      const {
-        x: l,
-        y: e,
-        placement: s
-      } = c, {
-        mainAxis: t = !0,
-        crossAxis: a = !1,
-        limiter: r = {
-          fn: (x) => {
-            let {
-              x: y,
-              y: v
-            } = x;
-            return {
-              x: y,
-              y: v
-            };
-          }
-        },
-        ...d
-      } = X(o, c), g = {
-        x: l,
-        y: e
-      }, u = await K(c, d), n = F(Y(s)), m = nt(n);
-      let i = g[m], f = g[n];
-      if (t) {
-        const x = m === "y" ? "top" : "left", y = m === "y" ? "bottom" : "right", v = i + u[x], A = i - u[y];
-        i = z(v, i, A);
-      }
-      if (a) {
-        const x = n === "y" ? "top" : "left", y = n === "y" ? "bottom" : "right", v = f + u[x], A = f - u[y];
-        f = z(v, f, A);
-      }
-      const h = r.fn({
-        ...c,
-        [m]: i,
-        [n]: f
-      });
-      return {
-        ...h,
-        data: {
-          x: h.x - l,
-          y: h.y - e,
-          enabled: {
-            [m]: t,
-            [n]: a
-          }
-        }
-      };
-    }
-  };
-};
 export {
-  lt as arrow,
-  ct as computePosition,
-  K as detectOverflow,
-  at as flip,
-  rt as inline,
-  ft as offset,
-  I as rectToClientRect,
-  mt as shift
+  S as clamp,
+  O as createCoords,
+  w as evaluate,
+  y as expandPaddingObject,
+  M as floor,
+  g as getAlignment,
+  d as getAlignmentAxis,
+  j as getAlignmentSides,
+  x as getAxisLength,
+  C as getExpandedPlacements,
+  s as getOppositeAlignmentPlacement,
+  h as getOppositeAxis,
+  L as getOppositeAxisPlacements,
+  u as getOppositePlacement,
+  E as getPaddingObject,
+  f as getSide,
+  b as getSideAxis,
+  a as max,
+  l as min,
+  R as rectToClientRect,
+  P as round
 };
 //# sourceMappingURL=annotorious-react.es23.js.map