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

package/components/get-css-variable-YlLiVgo8.js

@@ -0,0 +1,1413 @@
+/*! * A kit of modern Luzmo Web Components for analytics in your web application.
+ * 
+ * Copyright © 2025 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 Pe(e) {
+  if (Array.isArray(e)) return e;
+}
+function je(e, r) {
+  var t = e == null ? null : typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (t != null) {
+    var n, i, a, o, l = [], u = !0, c = !1;
+    try {
+      if (a = (t = t.call(e)).next, r !== 0) for (; !(u = (n = a.call(t)).done) && (l.push(n.value), l.length !== r); u = !0) ;
+    } catch (f) {
+      c = !0, i = f;
+    } finally {
+      try {
+        if (!u && t.return != null && (o = t.return(), Object(o) !== o)) return;
+      } finally {
+        if (c) throw i;
+      }
+    }
+    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 be(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 xe() {
+  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 he(e, r) {
+  return Pe(e) || je(e, r) || be(e, r) || xe();
+}
+var X = {}, W = {}, ne;
+function we() {
+  if (ne) return W;
+  ne = 1, Object.defineProperty(W, "__esModule", { value: !0 }), W.bind = void 0;
+  function e(r, t) {
+    var n = t.type, i = t.listener, a = t.options;
+    return r.addEventListener(n, i, a), function() {
+      r.removeEventListener(n, i, a);
+    };
+  }
+  return W.bind = e, W;
+}
+var M = {}, ae;
+function Ie() {
+  if (ae) return M;
+  ae = 1;
+  var e = M && M.__assign || function() {
+    return e = Object.assign || function(a) {
+      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) && (a[c] = o[c]);
+      }
+      return a;
+    }, e.apply(this, arguments);
+  };
+  Object.defineProperty(M, "__esModule", { value: !0 }), M.bindAll = void 0;
+  var r = /* @__PURE__ */ we();
+  function t(a) {
+    if (!(typeof a > "u"))
+      return typeof a == "boolean" ? {
+        capture: a
+      } : a;
+  }
+  function n(a, o) {
+    if (o == null)
+      return a;
+    var l = e(e({}, a), { options: e(e({}, t(o)), t(a.options)) });
+    return l;
+  }
+  function i(a, o, l) {
+    var u = o.map(function(c) {
+      var f = n(c, l);
+      return (0, r.bind)(a, f);
+    });
+    return function() {
+      u.forEach(function(f) {
+        return f();
+      });
+    };
+  }
+  return M.bindAll = i, M;
+}
+var ie;
+function Ce() {
+  return ie || (ie = 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__ */ Ie();
+    Object.defineProperty(e, "bindAll", { enumerable: !0, get: function() {
+      return t.bindAll;
+    } });
+  }(X)), X;
+}
+var H = /* @__PURE__ */ Ce();
+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 Fe(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 Me(e) {
+  var r = Fe(e, "string");
+  return L(r) == "symbol" ? r : r + "";
+}
+function _(e, r, t) {
+  return (r = Me(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : e[r] = t, e;
+}
+var De = 2147483647, Oe = "data-pdnd-honey-pot";
+function oe(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function ue(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? oe(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : oe(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+var $ = 2, le = $ / 2;
+function He(e) {
+  return {
+    x: Math.floor(e.x),
+    y: Math.floor(e.y)
+  };
+}
+function Ke(e) {
+  return {
+    x: e.x - le,
+    y: e.y - le
+  };
+}
+function Re(e) {
+  return {
+    x: Math.max(e.x, 0),
+    y: Math.max(e.y, 0)
+  };
+}
+function We(e) {
+  return {
+    x: Math.min(e.x, window.innerWidth - $),
+    y: Math.min(e.y, window.innerHeight - $)
+  };
+}
+function ce(e) {
+  var r = e.client, t = We(Re(Ke(He(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 ke(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 Ne(e) {
+  var r = e.initial, t = document.createElement("div");
+  t.setAttribute(Oe, "true");
+  var n = ce({
+    client: r
+  });
+  Object.assign(t.style, ue(ue({
+    // 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 i = H.bind(window, {
+    type: "pointermove",
+    listener: function(o) {
+      var l = {
+        x: o.clientX,
+        y: o.clientY
+      };
+      n = ce({
+        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 (i(), ke({
+      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 Le() {
+  var e = null;
+  function r() {
+    return e = null, H.bind(window, {
+      type: "pointermove",
+      listener: function(i) {
+        e = {
+          x: i.clientX,
+          y: i.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(a) {
+      var o = a.eventName, l = a.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 = Ne({
+          initial: f
+        });
+      }
+      if (o === "onDrop") {
+        var p, v = l.location.current.input;
+        (p = n) === null || p === void 0 || p({
+          current: {
+            x: v.clientX,
+            y: v.clientY
+          }
+        }), n = null, e = null;
+      }
+    };
+  }
+  return {
+    bindEvents: r,
+    getOnPostDispatch: t
+  };
+}
+function $e(e) {
+  if (Array.isArray(e)) return V(e);
+}
+function Ue(e) {
+  if (typeof Symbol < "u" && e[Symbol.iterator] != null || e["@@iterator"] != null) return Array.from(e);
+}
+function Be() {
+  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 $e(e) || Ue(e) || be(e) || Be();
+}
+function Se(e) {
+  return e instanceof Element && e.hasAttribute(Oe);
+}
+function Xe(e) {
+  var r = document.elementsFromPoint(e.x, e.y), t = he(r, 2), n = t[0], i = t[1];
+  return n ? Se(n) ? i ?? null : n : null;
+}
+function ee(e) {
+  var r = null;
+  return function() {
+    if (!r) {
+      for (var n = arguments.length, i = new Array(n), a = 0; a < n; a++)
+        i[a] = arguments[a];
+      var o = e.apply(this, i);
+      r = {
+        result: o
+      };
+    }
+    return r.result;
+  };
+}
+var Ye = ee(function() {
+  return navigator.userAgent.includes("Firefox");
+}), B = 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 B() ? r.hasOwnProperty(Z.isLeavingWindow) : !1;
+}
+(function() {
+  if (typeof window > "u" || !B())
+    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(a) {
+        !t.isOverWindow && t.enterCount === 0 && (a[Z.isEnteringWindow] = !0), t.isOverWindow = !0, t.enterCount++;
+      }
+    }, {
+      type: "dragleave",
+      listener: function(a) {
+        t.enterCount--, t.isOverWindow && t.enterCount === 0 && (a[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 ze(e) {
+  return "nodeName" in e;
+}
+function Ge(e) {
+  return ze(e) && e.ownerDocument !== document;
+}
+function Ve(e) {
+  var r = e.dragLeave, t = r.type, n = r.relatedTarget;
+  return t !== "dragleave" ? !1 : B() ? qe({
+    dragLeave: r
+  }) : n == null ? !0 : Ye() ? Ge(n) : n instanceof HTMLIFrameElement;
+}
+function Ze(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 k(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 Je = function(r) {
+  var t = [], n = null, i = 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 i.cancel = function() {
+    n && (cancelAnimationFrame(n), n = null);
+  }, i;
+}, Y = Je(function(e) {
+  return e();
+}), U = /* @__PURE__ */ function() {
+  var e = null;
+  function r(n) {
+    var i = requestAnimationFrame(function() {
+      e = null, n();
+    });
+    e = {
+      frameId: i,
+      fn: n
+    };
+  }
+  function t() {
+    e && (cancelAnimationFrame(e.frameId), e.fn(), e = null);
+  }
+  return {
+    schedule: r,
+    flush: t
+  };
+}();
+function Qe(e) {
+  var r = e.source, t = e.initial, n = e.dispatchEvent, i = {
+    dropTargets: []
+  };
+  function a(l) {
+    n(l), i = {
+      dropTargets: l.payload.location.current.dropTargets
+    };
+  }
+  var o = {
+    start: function(u) {
+      var c = u.nativeSetDragImage, f = {
+        current: t,
+        previous: i,
+        initial: t
+      };
+      a({
+        eventName: "onGenerateDragPreview",
+        payload: {
+          source: r,
+          location: f,
+          nativeSetDragImage: c
+        }
+      }), U.schedule(function() {
+        a({
+          eventName: "onDragStart",
+          payload: {
+            source: r,
+            location: f
+          }
+        });
+      });
+    },
+    dragUpdate: function(u) {
+      var c = u.current;
+      U.flush(), Y.cancel(), a({
+        eventName: "onDropTargetChange",
+        payload: {
+          source: r,
+          location: {
+            initial: t,
+            previous: i,
+            current: c
+          }
+        }
+      });
+    },
+    drag: function(u) {
+      var c = u.current;
+      Y(function() {
+        U.flush();
+        var f = {
+          initial: t,
+          previous: i,
+          current: c
+        };
+        a({
+          eventName: "onDrag",
+          payload: {
+            source: r,
+            location: f
+          }
+        });
+      });
+    },
+    drop: function(u) {
+      var c = u.current, f = u.updatedSourcePayload;
+      U.flush(), Y.cancel(), a({
+        eventName: "onDrop",
+        payload: {
+          source: f ?? r,
+          location: {
+            current: c,
+            previous: i,
+            initial: t
+          }
+        }
+      });
+    }
+  };
+  return o;
+}
+var J = {
+  isActive: !1
+};
+function Ae() {
+  return !J.isActive;
+}
+function _e(e) {
+  return e.dataTransfer ? e.dataTransfer.setDragImage.bind(e.dataTransfer) : null;
+}
+function et(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 tt(e) {
+  var r = e.event, t = e.dragType, n = e.getDropTargetsOver, i = e.dispatchEvent;
+  if (!Ae())
+    return;
+  var a = rt({
+    event: r,
+    dragType: t,
+    getDropTargetsOver: n
+  });
+  J.isActive = !0;
+  var o = {
+    current: a
+  };
+  q({
+    event: r,
+    current: a.dropTargets
+  });
+  var l = Qe({
+    source: t.payload,
+    dispatchEvent: i,
+    initial: a
+  });
+  function u(d) {
+    var s = et({
+      current: o.current.dropTargets,
+      next: d.dropTargets
+    });
+    o.current = d, s && l.dragUpdate({
+      current: o.current
+    });
+  }
+  function c(d) {
+    var s = k(d), g = Se(d.target) ? Xe({
+      x: s.clientX,
+      y: s.clientY
+    }) : d.target, y = n({
+      target: g,
+      event: d,
+      input: s,
+      source: t.payload,
+      current: o.current.dropTargets
+    });
+    y.length && (d.preventDefault(), q({
+      event: d,
+      current: y
+    })), u({
+      dropTargets: y,
+      input: s
+    });
+  }
+  function f() {
+    o.current.dropTargets.length && u({
+      dropTargets: [],
+      input: o.current.input
+    }), l.drop({
+      current: o.current,
+      updatedSourcePayload: null
+    }), p();
+  }
+  function p() {
+    J.isActive = !1, v();
+  }
+  var v = 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(s) {
+        c(s), l.drag({
+          current: o.current
+        });
+      }
+    }, {
+      type: "dragenter",
+      listener: c
+    }, {
+      type: "dragleave",
+      listener: function(s) {
+        Ve({
+          dragLeave: s
+        }) && (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(s) {
+        if (o.current = {
+          dropTargets: o.current.dropTargets,
+          input: k(s)
+        }, !o.current.dropTargets.length) {
+          f();
+          return;
+        }
+        s.preventDefault(), q({
+          event: s,
+          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(s) : null
+        }), p();
+      }
+    }, {
+      // "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(s) {
+        o.current = {
+          dropTargets: o.current.dropTargets,
+          input: k(s)
+        }, f();
+      }
+    }].concat(Te(Ze({
+      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: _e(r)
+  });
+}
+function q(e) {
+  var r, t = e.event, n = e.current, i = (r = n[0]) === null || r === void 0 ? void 0 : r.dropEffect;
+  i != null && t.dataTransfer && (t.dataTransfer.dropEffect = i);
+}
+function rt(e) {
+  var r = e.event, t = e.dragType, n = e.getDropTargetsOver, i = k(r);
+  if (t.startedFrom === "external")
+    return {
+      input: i,
+      dropTargets: []
+    };
+  var a = n({
+    input: i,
+    source: t.payload,
+    target: r.target,
+    event: r,
+    current: []
+  });
+  return {
+    input: i,
+    dropTargets: a
+  };
+}
+var se = {
+  canStart: Ae,
+  start: tt
+}, Q = /* @__PURE__ */ new Map();
+function nt(e) {
+  var r = e.typeKey, t = e.mount, n = Q.get(r);
+  if (n)
+    return n.usageCount++, n;
+  var i = {
+    typeKey: r,
+    unmount: t(),
+    usageCount: 1
+  };
+  return Q.set(r, i), i;
+}
+function at(e) {
+  var r = nt(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(i) {
+      return i();
+    });
+  };
+}
+function Ee(e, r) {
+  var t = r.attribute, n = r.value;
+  return e.setAttribute(t, n), function() {
+    return e.removeAttribute(t);
+  };
+}
+function fe(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).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 ? fe(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : fe(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 = it(e)) || r) {
+      t && (e = t);
+      var n = 0, i = function() {
+      };
+      return { s: i, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(c) {
+        throw c;
+      }, f: i };
+    }
+    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 a, 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, a = c;
+  }, f: function() {
+    try {
+      o || t.return == null || t.return();
+    } finally {
+      if (l) throw a;
+    }
+  } };
+}
+function it(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 ot(e) {
+  var r = e.typeKey, t = e.defaultDropEffect, n = /* @__PURE__ */ new WeakMap(), i = "data-drop-target-for-".concat(r), a = "[".concat(i, "]");
+  function o(d) {
+    return n.set(d.element, d), function() {
+      return n.delete(d.element);
+    };
+  }
+  function l(d) {
+    return te(Ee(d.element, {
+      attribute: i,
+      value: "true"
+    }), o(d));
+  }
+  function u(d) {
+    var s, g, y, T, w = d.source, D = d.target, m = d.input, S = d.event, b = d.result, h = b === void 0 ? [] : b;
+    if (S === void 0)
+      return h;
+    const E = S.composedPath();
+    if (D = E.find((K) => K instanceof Element ? K.hasAttribute("data-drop-target-for-element") : !1), D = D ?? E[0], !(D instanceof Element))
+      return D instanceof Node ? u({
+        source: w,
+        target: D.parentElement,
+        input: m,
+        result: h
+      }) : h;
+    var j = D.closest(a);
+    if (j == null)
+      return h;
+    var O = n.get(j);
+    if (O == null)
+      return h;
+    var P = {
+      input: m,
+      source: w,
+      element: O.element
+    };
+    if (O.canDrop && !O.canDrop(P))
+      return u({
+        source: w,
+        target: O.element.parentElement,
+        input: m,
+        result: h
+      });
+    var x = (s = (g = O.getData) === null || g === void 0 ? void 0 : g.call(O, P)) !== null && s !== void 0 ? s : {}, A = (y = (T = O.getDropEffect) === null || T === void 0 ? void 0 : T.call(O, P)) !== null && y !== void 0 ? y : t, I = {
+      data: x,
+      element: O.element,
+      dropEffect: A,
+      // we are collecting _actual_ drop targets, so these are
+      // being applied _not_ due to stickiness
+      isActiveDueToStickiness: !1
+    };
+    return u({
+      source: w,
+      target: O.element.parentElement,
+      input: m,
+      // Using bubble ordering. Same ordering as `event.getPath()`
+      result: [].concat(Te(h), [I])
+    });
+  }
+  function c(d) {
+    var s = d.eventName, g = d.payload, y = z(g.location.current.dropTargets), T;
+    try {
+      for (y.s(); !(T = y.n()).done; ) {
+        var w, D = T.value, m = n.get(D.element), S = F(F({}, g), {}, {
+          self: D
+        });
+        m == null || (w = m[s]) === null || w === void 0 || w.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
+          S
+        );
+      }
+    } catch (b) {
+      y.e(b);
+    } finally {
+      y.f();
+    }
+  }
+  var f = {
+    onGenerateDragPreview: c,
+    onDrag: c,
+    onDragStart: c,
+    onDrop: c,
+    onDropTargetChange: function(s) {
+      var g = s.payload, y = new Set(g.location.current.dropTargets.map(function(R) {
+        return R.element;
+      })), T = /* @__PURE__ */ new Set(), w = z(g.location.previous.dropTargets), D;
+      try {
+        for (w.s(); !(D = w.n()).done; ) {
+          var m, S = D.value;
+          T.add(S.element);
+          var b = n.get(S.element), h = y.has(S.element), E = F(F({}, g), {}, {
+            self: S
+          });
+          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) {
+        w.e(R);
+      } finally {
+        w.f();
+      }
+      var O = z(g.location.current.dropTargets), P;
+      try {
+        for (O.s(); !(P = O.n()).done; ) {
+          var x, A, I = P.value;
+          if (!T.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) {
+        O.e(R);
+      } finally {
+        O.f();
+      }
+    }
+  };
+  function p(d) {
+    f[d.eventName](d);
+  }
+  function v(d) {
+    var s = d.source, g = d.target, y = d.input, T = d.event, w = d.current, D = u({
+      source: s,
+      target: g,
+      event: T,
+      input: y
+    });
+    if (D.length >= w.length)
+      return D;
+    for (var m = G(w), S = G(D), b = [], h = 0; h < m.length; h++) {
+      var E, j = m[h], O = S[h];
+      if (O != null) {
+        b.push(O);
+        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: s,
+        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: v,
+    dispatchEvent: p
+  };
+}
+function ut(e, r) {
+  var t = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+  if (!t) {
+    if (Array.isArray(e) || (t = lt(e)) || r) {
+      t && (e = t);
+      var n = 0, i = function() {
+      };
+      return { s: i, n: function() {
+        return n >= e.length ? { done: !0 } : { done: !1, value: e[n++] };
+      }, e: function(c) {
+        throw c;
+      }, f: i };
+    }
+    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 a, 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, a = c;
+  }, f: function() {
+    try {
+      o || t.return == null || t.return();
+    } finally {
+      if (l) throw a;
+    }
+  } };
+}
+function lt(e, r) {
+  if (e) {
+    if (typeof e == "string") return pe(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) ? pe(e, r) : void 0;
+  }
+}
+function pe(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 ge(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    r && (n = n.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(e, i).enumerable;
+    })), t.push.apply(t, n);
+  }
+  return t;
+}
+function ct(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = arguments[r] != null ? arguments[r] : {};
+    r % 2 ? ge(Object(t), !0).forEach(function(n) {
+      _(e, n, t[n]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ge(Object(t)).forEach(function(n) {
+      Object.defineProperty(e, n, Object.getOwnPropertyDescriptor(t, n));
+    });
+  }
+  return e;
+}
+function dt() {
+  var e = /* @__PURE__ */ new Set(), r = null;
+  function t(a) {
+    r && (!a.canMonitor || a.canMonitor(r.canMonitorArgs)) && r.active.add(a);
+  }
+  function n(a) {
+    var o = ct({}, a);
+    return e.add(o), t(o), function() {
+      e.delete(o), r && r.active.delete(o);
+    };
+  }
+  function i(a) {
+    var o = a.eventName, l = a.payload;
+    if (o === "onGenerateDragPreview") {
+      r = {
+        canMonitorArgs: {
+          initial: l.location.initial,
+          source: l.source
+        },
+        active: /* @__PURE__ */ new Set()
+      };
+      var u = ut(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 p = Array.from(r.active), v = 0, d = p; v < d.length; v++) {
+        var s = d[v];
+        if (r.active.has(s)) {
+          var g;
+          (g = s[o]) === null || g === void 0 || g.call(s, l);
+        }
+      }
+      o === "onDrop" && (r.active.clear(), r = null);
+    }
+  }
+  return {
+    dispatchEvent: i,
+    monitorForConsumers: n
+  };
+}
+function st(e) {
+  var r = e.typeKey, t = e.mount, n = e.dispatchEventToSource, i = e.onPostDispatch, a = e.defaultDropEffect, o = dt(), l = ot({
+    typeKey: r,
+    defaultDropEffect: a
+  });
+  function u(p) {
+    n == null || n(p), l.dispatchEvent(p), o.dispatchEvent(p), i == null || i(p);
+  }
+  function c(p) {
+    var v = p.event, d = p.dragType;
+    se.start({
+      event: v,
+      dragType: d,
+      getDropTargetsOver: l.getIsOver,
+      dispatchEvent: u
+    });
+  }
+  function f() {
+    function p() {
+      var v = {
+        canStart: se.canStart,
+        start: c
+      };
+      return t(v);
+    }
+    return at({
+      typeKey: r,
+      mount: p
+    });
+  }
+  return {
+    registerUsage: f,
+    dropTarget: l.dropTargetForConsumers,
+    monitor: o.monitorForConsumers
+  };
+}
+var ft = ee(function() {
+  return navigator.userAgent.toLocaleLowerCase().includes("android");
+}), vt = "pdnd:android-fallback", ye = "text/plain", pt = "text/uri-list", gt = "application/vnd.pdnd", N = /* @__PURE__ */ new WeakMap();
+function yt(e) {
+  return N.set(e.element, e), function() {
+    N.delete(e.element);
+  };
+}
+var me = Le(), re = st({
+  typeKey: "element",
+  defaultDropEffect: "move",
+  mount: function(r) {
+    return te(me.bindEvents(), H.bind(document, {
+      type: "dragstart",
+      listener: function(n) {
+        var i, a, o, l, u, c;
+        if (!r.canStart(n) || n.defaultPrevented || !n.dataTransfer)
+          return;
+        const p = n.composedPath().find((h) => h instanceof HTMLElement && N.has(h));
+        if (!p)
+          return null;
+        const v = N.get(p);
+        if (!v)
+          return null;
+        var d = k(n), s = {
+          element: v.element,
+          dragHandle: (i = v.dragHandle) !== null && i !== void 0 ? i : null,
+          input: d
+        };
+        if (v.canDrag && !v.canDrag(s))
+          return n.preventDefault(), null;
+        if (v.dragHandle) {
+          const E = (p.shadowRoot || document).elementFromPoint(d.clientX, d.clientY);
+          if (!v.dragHandle.contains(E))
+            return n.preventDefault(), null;
+        }
+        var g = (a = (o = v.getInitialDataForExternal) === null || o === void 0 ? void 0 : o.call(v, s)) !== null && a !== void 0 ? a : null;
+        if (g)
+          for (var y = 0, T = Object.entries(g); y < T.length; y++) {
+            var w = he(T[y], 2), D = w[0], m = w[1];
+            n.dataTransfer.setData(D, m ?? "");
+          }
+        ft() && !n.dataTransfer.types.includes(ye) && !n.dataTransfer.types.includes(pt) && n.dataTransfer.setData(ye, vt), n.dataTransfer.setData(gt, "");
+        var S = {
+          element: v.element,
+          dragHandle: (l = v.dragHandle) !== null && l !== void 0 ? l : null,
+          data: (u = (c = v.getInitialData) === null || c === void 0 ? void 0 : c.call(v, s)) !== null && u !== void 0 ? u : {}
+        }, b = {
+          type: "element",
+          payload: S,
+          startedFrom: "internal"
+        };
+        r.start({
+          event: n,
+          dragType: b
+        });
+      }
+    }));
+  },
+  dispatchEventToSource: function(r) {
+    var t, n, i = r.eventName, a = r.payload;
+    (t = N.get(a.source.element)) === null || t === void 0 || (n = t[i]) === 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
+      a
+    );
+  },
+  onPostDispatch: me.getOnPostDispatch()
+}), ht = re.dropTarget, mt = re.monitor;
+function wt(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(),
+    yt(e),
+    Ee(e.element, {
+      attribute: "draggable",
+      value: "true"
+    })
+  );
+}
+function bt() {
+  return {
+    x: 0,
+    y: 0
+  };
+}
+function Dt(e) {
+  var r = e.render, t = e.nativeSetDragImage, n = e.getOffset, i = n === void 0 ? bt : n, a = document.createElement("div");
+  Object.assign(a.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(a);
+  var o = r({
+    container: a
+  });
+  queueMicrotask(function() {
+    var c = i({
+      container: a
+    });
+    if (B()) {
+      var f = a.getBoundingClientRect();
+      if (f.width === 0)
+        return;
+      a.style.left = "-".concat(f.width - 1e-4, "px");
+    }
+    t == null || t(a, c.x, c.y);
+  });
+  function l() {
+    u(), o == null || o(), document.body.removeChild(a);
+  }
+  var u = mt({
+    // 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 Ot = (e, r) => {
+  let t = getComputedStyle(e).getPropertyValue(r);
+  for (; !t && e.parentElement; )
+    e = e.parentElement, t = getComputedStyle(e).getPropertyValue(r);
+  return t.trim();
+};
+export {
+  _,
+  ht as a,
+  wt as d,
+  Ot as g,
+  Dt as s
+};