@luzmo/analytics-components-kit 1.0.1-alpha.2 → 1.0.1-alpha.4

package/lib/get-css-variable-BHHQ0SnL.js

@@ -0,0 +1,1444 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2024 Luzmo
+ * All rights reserved.
+ * Luzmo web components (“Luzmo Web Components”)
+ * must be used according to the Luzmo Terms of Service.
+ * This license allows users with a current active Luzmo account
+ * to use the Luzmo Web Components. This license terminates
+ * automatically if a user no longer has an active Luzmo account.
+ * Please view the Luzmo Terms of Service at: https://www.luzmo.com/information-pages/terms-of-use.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * */
+function ne(e) {
+  return e == null;
+}
+function je(e) {
+  return typeof e == "string" || e instanceof String;
+}
+function xe(e) {
+  return !Number.isNaN(e) && Number.isFinite(e);
+}
+function Ie(e) {
+  return typeof e == "boolean";
+}
+function Ce(e) {
+  return e !== null && typeof e == "object" && !Array.isArray(e);
+}
+function Fe(e) {
+  return e !== null && typeof e == "object" && Object.keys(e).length === 0;
+}
+function At(e, r, t) {
+  if (je(e) || xe(e) || Ie(e))
+    return e.toString();
+  if (ne(e) || !Ce(e) || Fe(e))
+    return "";
+  let n = "";
+  const a = Object.keys(e);
+  return r && e[r] && (n = e[r]), (ne(n) || n === "") && (a != null && a.length) && (n = e[a[0]]), n;
+}
+function Me(e) {
+  if (Array.isArray(e)) return e;
+}
+function He(e, r) {
+  var t = e == null ? null : typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (t != null) {
+    var n, a, i, o, l = [], u = !0, c = !1;
+    try {
+      if (i = (t = t.call(e)).next, r !== 0) for (; !(u = (n = i.call(t)).done) && (l.push(n.value), l.length !== r); u = !0) ;
+    } catch (f) {
+      c = !0, a = f;
+    } finally {
+      try {
+        if (!u && t.return != null && (o = t.return(), Object(o) !== o)) return;
+      } finally {
+        if (c) throw a;
+      }
+    }
+    return l;
+  }
+}
+function V(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
+  return n;
+}
+function he(e, r) {
+  if (e) {
+    if (typeof e == "string") return V(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? V(e, r) : void 0;
+  }
+}
+function Ke() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function Oe(e, r) {
+  return Me(e) || He(e, r) || he(e, r) || Ke();
+}
+var X = {}, k = {}, ae;
+function we() {
+  if (ae) return k;
+  ae = 1, Object.defineProperty(k, "__esModule", { value: !0 }), k.bind = void 0;
+  function e(r, t) {
+    var n = t.type, a = t.listener, i = t.options;
+    return r.addEventListener(n, a, i), function() {
+      r.removeEventListener(n, a, i);
+    };
+  }
+  return k.bind = e, k;
+}
+var M = {}, ie;
+function Re() {
+  if (ie) return M;
+  ie = 1;
+  var e = M && M.__assign || function() {
+    return e = Object.assign || function(i) {
+      for (var o, l = 1, u = arguments.length; l < u; l++) {
+        o = arguments[l];
+        for (var c in o) Object.prototype.hasOwnProperty.call(o, c) && (i[c] = o[c]);
+      }
+      return i;
+    }, e.apply(this, arguments);
+  };
+  Object.defineProperty(M, "__esModule", { value: !0 }), M.bindAll = void 0;
+  var r = /* @__PURE__ */ we();
+  function t(i) {
+    if (!(typeof i > "u"))
+      return typeof i == "boolean" ? {
+        capture: i
+      } : i;
+  }
+  function n(i, o) {
+    if (o == null)
+      return i;
+    var l = e(e({}, i), { options: e(e({}, t(o)), t(i.options)) });
+    return l;
+  }
+  function a(i, o, l) {
+    var u = o.map(function(c) {
+      var f = n(c, l);
+      return (0, r.bind)(i, f);
+    });
+    return function() {
+      u.forEach(function(f) {
+        return f();
+      });
+    };
+  }
+  return M.bindAll = a, M;
+}
+var oe;
+function ke() {
+  return oe || (oe = 1, function(e) {
+    Object.defineProperty(e, "__esModule", { value: !0 }), e.bindAll = e.bind = void 0;
+    var r = /* @__PURE__ */ we();
+    Object.defineProperty(e, "bind", { enumerable: !0, get: function() {
+      return r.bind;
+    } });
+    var t = /* @__PURE__ */ Re();
+    Object.defineProperty(e, "bindAll", { enumerable: !0, get: function() {
+      return t.bindAll;
+    } });
+  }(X)), X;
+}
+var H = /* @__PURE__ */ ke();
+function L(e) {
+  "@babel/helpers - typeof";
+  return L = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(r) {
+    return typeof r;
+  } : function(r) {
+    return r && typeof Symbol == "function" && r.constructor === Symbol && r !== Symbol.prototype ? "symbol" : typeof r;
+  }, L(e);
+}
+function Ne(e, r) {
+  if (L(e) != "object" || !e) return e;
+  var t = e[Symbol.toPrimitive];
+  if (t !== void 0) {
+    var n = t.call(e, r);
+    if (L(n) != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (r === "string" ? String : Number)(e);
+}
+function We(e) {
+  var r = Ne(e, "string");
+  return L(r) == "symbol" ? r : r + "";
+}
+function _(e, r, t) {
+  return (r = We(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+var De = 2147483647, Se = "data-pdnd-honey-pot";
+function ue(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function le(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? ue(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ue(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+var $ = 2, ce = $ / 2;
+function Le(e) {
+  return {
+    x: Math.floor(e.x),
+    y: Math.floor(e.y)
+  };
+}
+function $e(e) {
+  return {
+    x: e.x - ce,
+    y: e.y - ce
+  };
+}
+function Be(e) {
+  return {
+    x: Math.max(e.x, 0),
+    y: Math.max(e.y, 0)
+  };
+}
+function Ue(e) {
+  return {
+    x: Math.min(e.x, window.innerWidth - $),
+    y: Math.min(e.y, window.innerHeight - $)
+  };
+}
+function se(e) {
+  var r = e.client, t = Ue(Be($e(Le(r))));
+  return DOMRect.fromRect({
+    x: t.x,
+    y: t.y,
+    width: $,
+    height: $
+  });
+}
+function de(e) {
+  var r = e.clientRect;
+  return {
+    left: "".concat(r.left, "px"),
+    top: "".concat(r.top, "px"),
+    width: "".concat(r.width, "px"),
+    height: "".concat(r.height, "px")
+  };
+}
+function Xe(e) {
+  var r = e.client, t = e.clientRect;
+  return (
+    // is within horizontal bounds
+    r.x >= t.x && r.x <= t.x + t.width && // is within vertical bounds
+    r.y >= t.y && r.y <= t.y + t.height
+  );
+}
+function Ye(e) {
+  var r = e.initial, t = document.createElement("div");
+  t.setAttribute(Se, "true");
+  var n = se({
+    client: r
+  });
+  Object.assign(t.style, le(le({
+    // Setting a background color explicitly to avoid any inherited styles.
+    // Looks like this could be `opacity: 0`, but worried that _might_
+    // cause the element to be ignored on some platforms.
+    // When debugging, set backgroundColor to something like "red".
+    backgroundColor: "transparent",
+    position: "fixed",
+    // Being explicit to avoid inheriting styles
+    padding: 0,
+    margin: 0,
+    boxSizing: "border-box"
+  }, de({
+    clientRect: n
+  })), {}, {
+    // We want this element to absorb pointer events,
+    // it's kind of the whole point 😉
+    pointerEvents: "auto",
+    // Want to make sure the honey pot is top of everything else.
+    // Don't need to worry about native drag previews, as they will
+    // have been rendered (and removed) before the honey pot is rendered
+    zIndex: De
+  })), document.body.appendChild(t);
+  var a = H.bind(window, {
+    type: "pointermove",
+    listener: function(o) {
+      var l = {
+        x: o.clientX,
+        y: o.clientY
+      };
+      n = se({
+        client: l
+      }), Object.assign(t.style, de({
+        clientRect: n
+      }));
+    },
+    // using capture so we are less likely to be impacted by event stopping
+    options: {
+      capture: !0
+    }
+  });
+  return function(o) {
+    var l = o.current;
+    if (a(), Xe({
+      client: l,
+      clientRect: n
+    })) {
+      t.remove();
+      return;
+    }
+    function u() {
+      c(), t.remove();
+    }
+    var c = H.bindAll(window, [
+      {
+        type: "pointerdown",
+        listener: u
+      },
+      {
+        type: "pointermove",
+        listener: u
+      },
+      {
+        type: "focusin",
+        listener: u
+      },
+      {
+        type: "focusout",
+        listener: u
+      },
+      // a 'pointerdown' should happen before 'dragstart', but just being super safe
+      {
+        type: "dragstart",
+        listener: u
+      },
+      // if the user has dragged something out of the window
+      // and then is dragging something back into the window
+      // the first events we will see are "dragenter" (and then "dragover").
+      // So if we see any of these we need to clear the post drag fix.
+      {
+        type: "dragenter",
+        listener: u
+      },
+      {
+        type: "dragover",
+        listener: u
+      }
+      // Not adding a "wheel" event listener, as "wheel" by itself does not
+      // resolve the bug.
+    ], {
+      // Using `capture` so less likely to be impacted by other code stopping events
+      capture: !0
+    });
+  };
+}
+function qe() {
+  var e = null;
+  function r() {
+    return e = null, H.bind(window, {
+      type: "pointermove",
+      listener: function(a) {
+        e = {
+          x: a.clientX,
+          y: a.clientY
+        };
+      },
+      // listening for pointer move in capture phase
+      // so we are less likely to be impacted by events being stopped.
+      options: {
+        capture: !0
+      }
+    });
+  }
+  function t() {
+    var n = null;
+    return function(i) {
+      var o = i.eventName, l = i.payload;
+      if (o === "onDragStart") {
+        var u, c = l.location.initial.input, f = (u = e) !== null && u !== void 0 ? u : {
+          x: c.clientX,
+          y: c.clientY
+        };
+        n = Ye({
+          initial: f
+        });
+      }
+      if (o === "onDrop") {
+        var v, p = l.location.current.input;
+        (v = n) === null || v === void 0 || v({
+          current: {
+            x: p.clientX,
+            y: p.clientY
+          }
+        }), n = null, e = null;
+      }
+    };
+  }
+  return {
+    bindEvents: r,
+    getOnPostDispatch: t
+  };
+}
+function ze(e) {
+  if (Array.isArray(e)) return V(e);
+}
+function Ge(e) {
+  if (typeof Symbol < "u" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+}
+function Ve() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function Te(e) {
+  return ze(e) || Ge(e) || he(e) || Ve();
+}
+function Ae(e) {
+  return e instanceof Element && e.hasAttribute(Se);
+}
+function Ze(e) {
+  var r = document.elementsFromPoint(e.x, e.y), t = Oe(r, 2), n = t[0], a = t[1];
+  return n ? Ae(n) ? a ?? null : n : null;
+}
+function ee(e) {
+  var r = null;
+  return function() {
+    if (!r) {
+      for (var n = arguments.length, a = new Array(n), i = 0; i < n; i++)
+        a[i] = arguments[i];
+      var o = e.apply(this, a);
+      r = {
+        result: o
+      };
+    }
+    return r.result;
+  };
+}
+var Je = ee(function() {
+  return navigator.userAgent.includes("Firefox");
+}), U = ee(function() {
+  var r = navigator, t = r.userAgent;
+  return t.includes("AppleWebKit") && !t.includes("Chrome");
+}), Z = {
+  isLeavingWindow: Symbol("leaving"),
+  isEnteringWindow: Symbol("entering")
+};
+function Qe(e) {
+  var r = e.dragLeave;
+  return U() ? r.hasOwnProperty(Z.isLeavingWindow) : !1;
+}
+(function() {
+  if (typeof window > "u" || !U())
+    return;
+  function r() {
+    return {
+      enterCount: 0,
+      isOverWindow: !1
+    };
+  }
+  var t = r();
+  function n() {
+    t = r();
+  }
+  H.bindAll(
+    window,
+    [{
+      type: "dragstart",
+      listener: function() {
+        t.enterCount = 0, t.isOverWindow = !0;
+      }
+    }, {
+      type: "drop",
+      listener: n
+    }, {
+      type: "dragend",
+      listener: n
+    }, {
+      type: "dragenter",
+      listener: function(i) {
+        !t.isOverWindow && t.enterCount === 0 && (i[Z.isEnteringWindow] = !0), t.isOverWindow = !0, t.enterCount++;
+      }
+    }, {
+      type: "dragleave",
+      listener: function(i) {
+        t.enterCount--, t.isOverWindow && t.enterCount === 0 && (i[Z.isLeavingWindow] = !0, t.isOverWindow = !1);
+      }
+    }],
+    // using `capture: true` so that adding event listeners
+    // in bubble phase will have the correct symbols
+    {
+      capture: !0
+    }
+  );
+})();
+function _e(e) {
+  return "nodeName" in e;
+}
+function et(e) {
+  return _e(e) && e.ownerDocument !== document;
+}
+function tt(e) {
+  var r = e.dragLeave, t = r.type, n = r.relatedTarget;
+  return t !== "dragleave" ? !1 : U() ? Qe({
+    dragLeave: r
+  }) : n == null ? !0 : Je() ? et(n) : n instanceof HTMLIFrameElement;
+}
+function rt(e) {
+  var r = e.onDragEnd;
+  return [
+    // ## Detecting drag ending for removed draggables
+    //
+    // If a draggable element is removed during a drag and the user drops:
+    // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+    // 2. if not over a valid drop target (or cancelled): we get nothing
+    // The "dragend" event will not fire on the source draggable if it has been
+    // removed from the DOM.
+    // So we need to figure out if a drag operation has finished by looking at other events
+    // We can do this by looking at other events
+    // ### First detection: "pointermove" events
+    // 1. "pointermove" events cannot fire during a drag and drop operation
+    // according to the spec. So if we get a "pointermove" it means that
+    // the drag and drop operations has finished. So if we get a "pointermove"
+    // we know that the drag is over
+    // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+    // other pointer events. However, firefox will allow a few
+    // pointer event to get through after a drag starts.
+    // The most I've seen is 3
+    {
+      type: "pointermove",
+      listener: /* @__PURE__ */ function() {
+        var t = 0;
+        return function() {
+          if (t < 20) {
+            t++;
+            return;
+          }
+          r();
+        };
+      }()
+    },
+    // ### Second detection: "pointerdown" events
+    // If we receive this event then we know that a drag operation has finished
+    // and potentially another one is about to start.
+    // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+    {
+      type: "pointerdown",
+      listener: r
+    }
+  ];
+}
+function N(e) {
+  return {
+    altKey: e.altKey,
+    button: e.button,
+    buttons: e.buttons,
+    ctrlKey: e.ctrlKey,
+    metaKey: e.metaKey,
+    shiftKey: e.shiftKey,
+    clientX: e.clientX,
+    clientY: e.clientY,
+    pageX: e.pageX,
+    pageY: e.pageY
+  };
+}
+var nt = function(r) {
+  var t = [], n = null, a = function() {
+    for (var o = arguments.length, l = new Array(o), u = 0; u < o; u++)
+      l[u] = arguments[u];
+    t = l, !n && (n = requestAnimationFrame(function() {
+      n = null, r.apply(void 0, t);
+    }));
+  };
+  return a.cancel = function() {
+    n && (cancelAnimationFrame(n), n = null);
+  }, a;
+}, Y = nt(function(e) {
+  return e();
+}), B = /* @__PURE__ */ function() {
+  var e = null;
+  function r(n) {
+    var a = requestAnimationFrame(function() {
+      e = null, n();
+    });
+    e = {
+      frameId: a,
+      fn: n
+    };
+  }
+  function t() {
+    e && (cancelAnimationFrame(e.frameId), e.fn(), e = null);
+  }
+  return {
+    schedule: r,
+    flush: t
+  };
+}();
+function at(e) {
+  var r = e.source, t = e.initial, n = e.dispatchEvent, a = {
+    dropTargets: []
+  };
+  function i(l) {
+    n(l), a = {
+      dropTargets: l.payload.location.current.dropTargets
+    };
+  }
+  var o = {
+    start: function(u) {
+      var c = u.nativeSetDragImage, f = {
+        current: t,
+        previous: a,
+        initial: t
+      };
+      i({
+        eventName: "onGenerateDragPreview",
+        payload: {
+          source: r,
+          location: f,
+          nativeSetDragImage: c
+        }
+      }), B.schedule(function() {
+        i({
+          eventName: "onDragStart",
+          payload: {
+            source: r,
+            location: f
+          }
+        });
+      });
+    },
+    dragUpdate: function(u) {
+      var c = u.current;
+      B.flush(), Y.cancel(), i({
+        eventName: "onDropTargetChange",
+        payload: {
+          source: r,
+          location: {
+            initial: t,
+            previous: a,
+            current: c
+          }
+        }
+      });
+    },
+    drag: function(u) {
+      var c = u.current;
+      Y(function() {
+        B.flush();
+        var f = {
+          initial: t,
+          previous: a,
+          current: c
+        };
+        i({
+          eventName: "onDrag",
+          payload: {
+            source: r,
+            location: f
+          }
+        });
+      });
+    },
+    drop: function(u) {
+      var c = u.current, f = u.updatedSourcePayload;
+      B.flush(), Y.cancel(), i({
+        eventName: "onDrop",
+        payload: {
+          source: f ?? r,
+          location: {
+            current: c,
+            previous: a,
+            initial: t
+          }
+        }
+      });
+    }
+  };
+  return o;
+}
+var J = {
+  isActive: !1
+};
+function Ee() {
+  return !J.isActive;
+}
+function it(e) {
+  return e.dataTransfer ? e.dataTransfer.setDragImage.bind(e.dataTransfer) : null;
+}
+function ot(e) {
+  var r = e.current, t = e.next;
+  if (r.length !== t.length)
+    return !0;
+  for (var n = 0; n < r.length; n++)
+    if (r[n].element !== t[n].element)
+      return !0;
+  return !1;
+}
+function ut(e) {
+  var r = e.event, t = e.dragType, n = e.getDropTargetsOver, a = e.dispatchEvent;
+  if (!Ee())
+    return;
+  var i = lt({
+    event: r,
+    dragType: t,
+    getDropTargetsOver: n
+  });
+  J.isActive = !0;
+  var o = {
+    current: i
+  };
+  q({
+    event: r,
+    current: i.dropTargets
+  });
+  var l = at({
+    source: t.payload,
+    dispatchEvent: a,
+    initial: i
+  });
+  function u(s) {
+    var d = ot({
+      current: o.current.dropTargets,
+      next: s.dropTargets
+    });
+    o.current = s, d && l.dragUpdate({
+      current: o.current
+    });
+  }
+  function c(s) {
+    var d = N(s), g = Ae(s.target) ? Ze({
+      x: d.clientX,
+      y: d.clientY
+    }) : s.target, y = n({
+      target: g,
+      event: s,
+      input: d,
+      source: t.payload,
+      current: o.current.dropTargets
+    });
+    y.length && (s.preventDefault(), q({
+      event: s,
+      current: y
+    })), u({
+      dropTargets: y,
+      input: d
+    });
+  }
+  function f() {
+    o.current.dropTargets.length && u({
+      dropTargets: [],
+      input: o.current.input
+    }), l.drop({
+      current: o.current,
+      updatedSourcePayload: null
+    }), v();
+  }
+  function v() {
+    J.isActive = !1, p();
+  }
+  var p = H.bindAll(
+    window,
+    [{
+      // 👋 Note: we are repurposing the `dragover` event as our `drag` event
+      // this is because firefox does not publish pointer coordinates during
+      // a `drag` event, but does for every other type of drag event
+      // `dragover` fires on all elements that are being dragged over
+      // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
+      // 🦊😤
+      type: "dragover",
+      listener: function(d) {
+        c(d), l.drag({
+          current: o.current
+        });
+      }
+    }, {
+      type: "dragenter",
+      listener: c
+    }, {
+      type: "dragleave",
+      listener: function(d) {
+        tt({
+          dragLeave: d
+        }) && (u({
+          input: o.current.input,
+          dropTargets: []
+        }), t.startedFrom === "external" && f());
+      }
+    }, {
+      // A "drop" can only happen if the browser allowed the drop
+      type: "drop",
+      listener: function(d) {
+        if (o.current = {
+          dropTargets: o.current.dropTargets,
+          input: N(d)
+        }, !o.current.dropTargets.length) {
+          f();
+          return;
+        }
+        d.preventDefault(), q({
+          event: d,
+          current: o.current.dropTargets
+        }), l.drop({
+          current: o.current,
+          // When dropping something native, we need to extract the latest
+          // `.items` from the "drop" event as it is now accessible
+          updatedSourcePayload: t.type === "external" ? t.getDropPayload(d) : null
+        }), v();
+      }
+    }, {
+      // "dragend" fires when on the drag source (eg a draggable element)
+      // when the drag is finished.
+      // "dragend" will fire after "drop" (if there was a successful drop)
+      // "dragend" does not fire if the draggable source has been removed during the drag
+      // or for external drag sources (eg files)
+      // This "dragend" listener will not fire if there was a successful drop
+      // as we will have already removed the event listener
+      type: "dragend",
+      listener: function(d) {
+        o.current = {
+          dropTargets: o.current.dropTargets,
+          input: N(d)
+        }, f();
+      }
+    }].concat(Te(rt({
+      onDragEnd: f
+    }))),
+    // Once we have started a managed drag operation it is important that we see / own all drag events
+    // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
+    // all "drop" events in the bubble phase on the `document.body`.
+    // This meant that we never saw the "drop" event.
+    {
+      capture: !0
+    }
+  );
+  l.start({
+    nativeSetDragImage: it(r)
+  });
+}
+function q(e) {
+  var r, t = e.event, n = e.current, a = (r = n[0]) === null || r === void 0 ? void 0 : r.dropEffect;
+  a != null && t.dataTransfer && (t.dataTransfer.dropEffect = a);
+}
+function lt(e) {
+  var r = e.event, t = e.dragType, n = e.getDropTargetsOver, a = N(r);
+  if (t.startedFrom === "external")
+    return {
+      input: a,
+      dropTargets: []
+    };
+  var i = n({
+    input: a,
+    source: t.payload,
+    target: r.target,
+    event: r,
+    current: []
+  });
+  return {
+    input: a,
+    dropTargets: i
+  };
+}
+var fe = {
+  canStart: Ee,
+  start: ut
+}, Q = /* @__PURE__ */ new Map();
+function ct(e) {
+  var r = e.typeKey, t = e.mount, n = Q.get(r);
+  if (n)
+    return n.usageCount++, n;
+  var a = {
+    typeKey: r,
+    unmount: t(),
+    usageCount: 1
+  };
+  return Q.set(r, a), a;
+}
+function st(e) {
+  var r = ct(e);
+  return function() {
+    r.usageCount--, !(r.usageCount > 0) && (r.unmount(), Q.delete(e.typeKey));
+  };
+}
+function te() {
+  for (var e = arguments.length, r = new Array(e), t = 0; t < e; t++)
+    r[t] = arguments[t];
+  return function() {
+    r.forEach(function(a) {
+      return a();
+    });
+  };
+}
+function Pe(e, r) {
+  var t = r.attribute, n = r.value;
+  return e.setAttribute(t, n), function() {
+    return e.removeAttribute(t);
+  };
+}
+function pe(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function F(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? pe(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : pe(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function z(e, r) {
+  var t = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!t) {
+    if (Array.isArray(e) || (t = dt(e)) || r) {
+      t && (e = t);
+      var n = 0, a = function() {
+      };
+      return { s: a, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(c) {
+        throw c;
+      }, f: a };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var i, o = !0, l = !1;
+  return { s: function() {
+    t = t.call(e);
+  }, n: function() {
+    var c = t.next();
+    return o = c.done, c;
+  }, e: function(c) {
+    l = !0, i = c;
+  }, f: function() {
+    try {
+      o || t.return == null || t.return();
+    } finally {
+      if (l) throw i;
+    }
+  } };
+}
+function dt(e, r) {
+  if (e) {
+    if (typeof e == "string") return ve(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? ve(e, r) : void 0;
+  }
+}
+function ve(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
+  return n;
+}
+function G(e) {
+  return e.slice(0).reverse();
+}
+function ft(e) {
+  var r = e.typeKey, t = e.defaultDropEffect, n = /* @__PURE__ */ new WeakMap(), a = "data-drop-target-for-".concat(r), i = "[".concat(a, "]");
+  function o(s) {
+    return n.set(s.element, s), function() {
+      return n.delete(s.element);
+    };
+  }
+  function l(s) {
+    return te(Pe(s.element, {
+      attribute: a,
+      value: "true"
+    }), o(s));
+  }
+  function u(s) {
+    var d, g, y, S, O = s.source, w = s.target, m = s.input, T = s.event, b = s.result, h = b === void 0 ? [] : b;
+    if (T === void 0)
+      return h;
+    const E = T.composedPath();
+    if (w = E.find((K) => K instanceof Element ? K.hasAttribute("data-drop-target-for-element") : !1), w = w ?? E[0], !(w instanceof Element))
+      return w instanceof Node ? u({
+        source: O,
+        target: w.parentElement,
+        input: m,
+        result: h
+      }) : h;
+    var j = w.closest(i);
+    if (j == null)
+      return h;
+    var D = n.get(j);
+    if (D == null)
+      return h;
+    var P = {
+      input: m,
+      source: O,
+      element: D.element
+    };
+    if (D.canDrop && !D.canDrop(P))
+      return u({
+        source: O,
+        target: D.element.parentElement,
+        input: m,
+        result: h
+      });
+    var x = (d = (g = D.getData) === null || g === void 0 ? void 0 : g.call(D, P)) !== null && d !== void 0 ? d : {}, A = (y = (S = D.getDropEffect) === null || S === void 0 ? void 0 : S.call(D, P)) !== null && y !== void 0 ? y : t, I = {
+      data: x,
+      element: D.element,
+      dropEffect: A,
+      // we are collecting _actual_ drop targets, so these are
+      // being applied _not_ due to stickiness
+      isActiveDueToStickiness: !1
+    };
+    return u({
+      source: O,
+      target: D.element.parentElement,
+      input: m,
+      // Using bubble ordering. Same ordering as `event.getPath()`
+      result: [].concat(Te(h), [I])
+    });
+  }
+  function c(s) {
+    var d = s.eventName, g = s.payload, y = z(g.location.current.dropTargets), S;
+    try {
+      for (y.s(); !(S = y.n()).done; ) {
+        var O, w = S.value, m = n.get(w.element), T = F(F({}, g), {}, {
+          self: w
+        });
+        m == null || (O = m[d]) === null || O === void 0 || O.call(
+          m,
+          // I cannot seem to get the types right here.
+          // TS doesn't seem to like that one event can need `nativeSetDragImage`
+          // @ts-expect-error
+          T
+        );
+      }
+    } catch (b) {
+      y.e(b);
+    } finally {
+      y.f();
+    }
+  }
+  var f = {
+    onGenerateDragPreview: c,
+    onDrag: c,
+    onDragStart: c,
+    onDrop: c,
+    onDropTargetChange: function(d) {
+      var g = d.payload, y = new Set(g.location.current.dropTargets.map(function(R) {
+        return R.element;
+      })), S = /* @__PURE__ */ new Set(), O = z(g.location.previous.dropTargets), w;
+      try {
+        for (O.s(); !(w = O.n()).done; ) {
+          var m, T = w.value;
+          S.add(T.element);
+          var b = n.get(T.element), h = y.has(T.element), E = F(F({}, g), {}, {
+            self: T
+          });
+          if (b == null || (m = b.onDropTargetChange) === null || m === void 0 || m.call(b, E), !h) {
+            var j;
+            b == null || (j = b.onDragLeave) === null || j === void 0 || j.call(b, E);
+          }
+        }
+      } catch (R) {
+        O.e(R);
+      } finally {
+        O.f();
+      }
+      var D = z(g.location.current.dropTargets), P;
+      try {
+        for (D.s(); !(P = D.n()).done; ) {
+          var x, A, I = P.value;
+          if (!S.has(I.element)) {
+            var K = F(F({}, g), {}, {
+              self: I
+            }), C = n.get(I.element);
+            C == null || (x = C.onDropTargetChange) === null || x === void 0 || x.call(C, K), C == null || (A = C.onDragEnter) === null || A === void 0 || A.call(C, K);
+          }
+        }
+      } catch (R) {
+        D.e(R);
+      } finally {
+        D.f();
+      }
+    }
+  };
+  function v(s) {
+    f[s.eventName](s);
+  }
+  function p(s) {
+    var d = s.source, g = s.target, y = s.input, S = s.event, O = s.current, w = u({
+      source: d,
+      target: g,
+      event: S,
+      input: y
+    });
+    if (w.length >= O.length)
+      return w;
+    for (var m = G(O), T = G(w), b = [], h = 0; h < m.length; h++) {
+      var E, j = m[h], D = T[h];
+      if (D != null) {
+        b.push(D);
+        continue;
+      }
+      var P = b[h - 1], x = m[h - 1];
+      if ((P == null ? void 0 : P.element) !== (x == null ? void 0 : x.element))
+        break;
+      var A = n.get(j.element);
+      if (!A)
+        break;
+      var I = {
+        input: y,
+        source: d,
+        element: A.element
+      };
+      if (A.canDrop && !A.canDrop(I) || !((E = A.getIsSticky) !== null && E !== void 0 && E.call(A, I)))
+        break;
+      b.push(F(F({}, j), {}, {
+        // making it clear to consumers this drop target is active due to stickiness
+        isActiveDueToStickiness: !0
+      }));
+    }
+    return G(b);
+  }
+  return {
+    dropTargetForConsumers: l,
+    getIsOver: p,
+    dispatchEvent: v
+  };
+}
+function pt(e, r) {
+  var t = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!t) {
+    if (Array.isArray(e) || (t = vt(e)) || r) {
+      t && (e = t);
+      var n = 0, a = function() {
+      };
+      return { s: a, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(c) {
+        throw c;
+      }, f: a };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  var i, o = !0, l = !1;
+  return { s: function() {
+    t = t.call(e);
+  }, n: function() {
+    var c = t.next();
+    return o = c.done, c;
+  }, e: function(c) {
+    l = !0, i = c;
+  }, f: function() {
+    try {
+      o || t.return == null || t.return();
+    } finally {
+      if (l) throw i;
+    }
+  } };
+}
+function vt(e, r) {
+  if (e) {
+    if (typeof e == "string") return ge(e, r);
+    var t = {}.toString.call(e).slice(8, -1);
+    return t === "Object" && e.constructor && (t = e.constructor.name), t === "Map" || t === "Set" ? Array.from(e) : t === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? ge(e, r) : void 0;
+  }
+}
+function ge(e, r) {
+  (r == null || r > e.length) && (r = e.length);
+  for (var t = 0, n = Array(r); t < r; t++) n[t] = e[t];
+  return n;
+}
+function ye(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(e, a).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function gt(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? ye(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ye(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function yt() {
+  var e = /* @__PURE__ */ new Set(), r = null;
+  function t(i) {
+    r && (!i.canMonitor || i.canMonitor(r.canMonitorArgs)) && r.active.add(i);
+  }
+  function n(i) {
+    var o = gt({}, i);
+    return e.add(o), t(o), function() {
+      e.delete(o), r && r.active.delete(o);
+    };
+  }
+  function a(i) {
+    var o = i.eventName, l = i.payload;
+    if (o === "onGenerateDragPreview") {
+      r = {
+        canMonitorArgs: {
+          initial: l.location.initial,
+          source: l.source
+        },
+        active: /* @__PURE__ */ new Set()
+      };
+      var u = pt(e), c;
+      try {
+        for (u.s(); !(c = u.n()).done; ) {
+          var f = c.value;
+          t(f);
+        }
+      } catch (y) {
+        u.e(y);
+      } finally {
+        u.f();
+      }
+    }
+    if (r) {
+      for (var v = Array.from(r.active), p = 0, s = v; p < s.length; p++) {
+        var d = s[p];
+        if (r.active.has(d)) {
+          var g;
+          (g = d[o]) === null || g === void 0 || g.call(d, l);
+        }
+      }
+      o === "onDrop" && (r.active.clear(), r = null);
+    }
+  }
+  return {
+    dispatchEvent: a,
+    monitorForConsumers: n
+  };
+}
+function mt(e) {
+  var r = e.typeKey, t = e.mount, n = e.dispatchEventToSource, a = e.onPostDispatch, i = e.defaultDropEffect, o = yt(), l = ft({
+    typeKey: r,
+    defaultDropEffect: i
+  });
+  function u(v) {
+    n == null || n(v), l.dispatchEvent(v), o.dispatchEvent(v), a == null || a(v);
+  }
+  function c(v) {
+    var p = v.event, s = v.dragType;
+    fe.start({
+      event: p,
+      dragType: s,
+      getDropTargetsOver: l.getIsOver,
+      dispatchEvent: u
+    });
+  }
+  function f() {
+    function v() {
+      var p = {
+        canStart: fe.canStart,
+        start: c
+      };
+      return t(p);
+    }
+    return st({
+      typeKey: r,
+      mount: v
+    });
+  }
+  return {
+    registerUsage: f,
+    dropTarget: l.dropTargetForConsumers,
+    monitor: o.monitorForConsumers
+  };
+}
+var bt = ee(function() {
+  return navigator.userAgent.toLocaleLowerCase().includes("android");
+}), ht = "pdnd:android-fallback", me = "text/plain", Ot = "text/uri-list", wt = "application/vnd.pdnd", W = /* @__PURE__ */ new WeakMap();
+function Dt(e) {
+  return W.set(e.element, e), function() {
+    W.delete(e.element);
+  };
+}
+var be = qe(), re = mt({
+  typeKey: "element",
+  defaultDropEffect: "move",
+  mount: function(r) {
+    return te(be.bindEvents(), H.bind(document, {
+      type: "dragstart",
+      listener: function(n) {
+        var a, i, o, l, u, c;
+        if (!r.canStart(n) || n.defaultPrevented || !n.dataTransfer)
+          return;
+        const v = n.composedPath().find((h) => h instanceof HTMLElement && W.has(h));
+        if (!v)
+          return null;
+        const p = W.get(v);
+        if (!p)
+          return null;
+        var s = N(n), d = {
+          element: p.element,
+          dragHandle: (a = p.dragHandle) !== null && a !== void 0 ? a : null,
+          input: s
+        };
+        if (p.canDrag && !p.canDrag(d))
+          return n.preventDefault(), null;
+        if (p.dragHandle) {
+          const E = (v.shadowRoot || document).elementFromPoint(s.clientX, s.clientY);
+          if (!p.dragHandle.contains(E))
+            return n.preventDefault(), null;
+        }
+        var g = (i = (o = p.getInitialDataForExternal) === null || o === void 0 ? void 0 : o.call(p, d)) !== null && i !== void 0 ? i : null;
+        if (g)
+          for (var y = 0, S = Object.entries(g); y < S.length; y++) {
+            var O = Oe(S[y], 2), w = O[0], m = O[1];
+            n.dataTransfer.setData(w, m ?? "");
+          }
+        bt() && !n.dataTransfer.types.includes(me) && !n.dataTransfer.types.includes(Ot) && n.dataTransfer.setData(me, ht), n.dataTransfer.setData(wt, "");
+        var T = {
+          element: p.element,
+          dragHandle: (l = p.dragHandle) !== null && l !== void 0 ? l : null,
+          data: (u = (c = p.getInitialData) === null || c === void 0 ? void 0 : c.call(p, d)) !== null && u !== void 0 ? u : {}
+        }, b = {
+          type: "element",
+          payload: T,
+          startedFrom: "internal"
+        };
+        r.start({
+          event: n,
+          dragType: b
+        });
+      }
+    }));
+  },
+  dispatchEventToSource: function(r) {
+    var t, n, a = r.eventName, i = r.payload;
+    (t = W.get(i.source.element)) === null || t === void 0 || (n = t[a]) === null || n === void 0 || n.call(
+      t,
+      // I cannot seem to get the types right here.
+      // TS doesn't seem to like that one event can need `nativeSetDragImage`
+      // @ts-expect-error
+      i
+    );
+  },
+  onPostDispatch: be.getOnPostDispatch()
+}), Et = re.dropTarget, St = re.monitor;
+function Pt(e) {
+  return te(
+    // making the draggable register the adapter rather than drop targets
+    // this is because you *must* have a draggable element to start a drag
+    // but you _might_ not have any drop targets immediately
+    // (You might create drop targets async)
+    re.registerUsage(),
+    Dt(e),
+    Pe(e.element, {
+      attribute: "draggable",
+      value: "true"
+    })
+  );
+}
+function Tt() {
+  return {
+    x: 0,
+    y: 0
+  };
+}
+function jt(e) {
+  var r = e.render, t = e.nativeSetDragImage, n = e.getOffset, a = n === void 0 ? Tt : n, i = document.createElement("div");
+  Object.assign(i.style, {
+    // Ensuring we don't cause reflow when adding the element to the page
+    // Using `position:fixed` rather than `position:absolute` so we are
+    // positioned on the current viewport.
+    // `position:fixed` also creates a new stacking context, so we don't need to do that here
+    position: "fixed",
+    // According to `mdn`, the element can be offscreen:
+    // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/setDragImage#imgelement
+    //
+    // However, that  information does not appear in the specs:
+    // https://html.spec.whatwg.org/multipage/dnd.html#dom-datatransfer-setdragimage-dev
+    //
+    // If the element is _completely_ offscreen, Safari@17.1 will cancel the drag
+    top: 0,
+    left: 0,
+    // Using maximum possible z-index so that this element will always be on top
+    // https://stackoverflow.com/questions/491052/minimum-and-maximum-value-of-z-index
+    // Did not use `layers` in `@atlaskit/theme` because:
+    // 1. This element is not a 'layer' in the conventional sense, as this element
+    //    is only created for a single frame for the browser to take a photo of it,
+    //    and then it is destroyed
+    // 2. Did not want to add a dependency onto `@atlaskit/theme`
+    // 3. Want to always be on top of product UI which might have higher z-index's
+    zIndex: De,
+    // Avoiding any additional events caused by the new element (being super safe)
+    pointerEvents: "none"
+  }), document.body.append(i);
+  var o = r({
+    container: i
+  });
+  queueMicrotask(function() {
+    var c = a({
+      container: i
+    });
+    if (U()) {
+      var f = i.getBoundingClientRect();
+      if (f.width === 0)
+        return;
+      i.style.left = "-".concat(f.width - 1e-4, "px");
+    }
+    t == null || t(i, c.x, c.y);
+  });
+  function l() {
+    u(), o == null || o(), document.body.removeChild(i);
+  }
+  var u = St({
+    // Remove portal in the dragstart event so that the user will never see it
+    onDragStart: l,
+    // Backup: remove portal when the drop finishes (this would be an error case)
+    onDrop: l
+  });
+}
+const xt = (e, r) => {
+  let t = getComputedStyle(e).getPropertyValue(r);
+  for (; !t && e.parentElement; )
+    e = e.parentElement, t = getComputedStyle(e).getPropertyValue(r);
+  return t.trim();
+};
+export {
+  _,
+  Et as a,
+  je as b,
+  xe as c,
+  Pt as d,
+  xt as g,
+  ne as i,
+  At as l,
+  jt as s
+};