@annotorious/react 3.7.20 → 3.7.21

package/dist/annotorious-react.es25.js

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