@industry-theme/backlogmd-kanban-panel 1.2.13 → 1.2.15

package/dist/panels.bundle.js

@@ -464,7 +464,7 @@ function Accessibility(_ref) {
   }));
   return container ? createPortal(markup, container) : markup;
 }
-var Action;
+var Action$1;
 (function(Action2) {
   Action2["DragStart"] = "dragStart";
   Action2["DragMove"] = "dragMove";
@@ -474,7 +474,7 @@ var Action;
   Action2["RegisterDroppable"] = "registerDroppable";
   Action2["SetDroppableDisabled"] = "setDroppableDisabled";
   Action2["UnregisterDroppable"] = "unregisterDroppable";
-})(Action || (Action = {}));
+})(Action$1 || (Action$1 = {}));
 function noop() {
 }
 function useSensor(sensor, options) {
@@ -497,7 +497,7 @@ function useSensors() {
     [...sensors]
   );
 }
-const defaultCoordinates = /* @__PURE__ */ Object.freeze({
+const defaultCoordinates$1 = /* @__PURE__ */ Object.freeze({
   x: 0,
   y: 0
 });
@@ -586,7 +586,7 @@ function getRectDelta(rect1, rect2) {
   return rect1 && rect2 ? {
     x: rect1.left - rect2.left,
     y: rect1.top - rect2.top
-  } : defaultCoordinates;
+  } : defaultCoordinates$1;
 }
 function createRectAdjustmentFn(modifier) {
   return function adjustClientRect(rect) {
@@ -792,11 +792,11 @@ function getScrollCoordinates(element2) {
     y: getScrollYCoordinate(element2)
   };
 }
-var Direction;
+var Direction$1;
 (function(Direction2) {
   Direction2[Direction2["Forward"] = 1] = "Forward";
   Direction2[Direction2["Backward"] = -1] = "Backward";
-})(Direction || (Direction = {}));
+})(Direction$1 || (Direction$1 = {}));
 function isDocumentScrollingElement(element2) {
   if (!canUseDOM || !element2) {
     return false;
@@ -868,17 +868,17 @@ function getScrollDirectionAndSpeed(scrollContainer, scrollContainerRect, _ref,
     width: scrollContainerRect.width * thresholdPercentage.x
   };
   if (!isTop && top <= scrollContainerRect.top + threshold.height) {
-    direction.y = Direction.Backward;
+    direction.y = Direction$1.Backward;
     speed.y = acceleration * Math.abs((scrollContainerRect.top + threshold.height - top) / threshold.height);
   } else if (!isBottom && bottom >= scrollContainerRect.bottom - threshold.height) {
-    direction.y = Direction.Forward;
+    direction.y = Direction$1.Forward;
     speed.y = acceleration * Math.abs((scrollContainerRect.bottom - threshold.height - bottom) / threshold.height);
   }
   if (!isRight && right >= scrollContainerRect.right - threshold.width) {
-    direction.x = Direction.Forward;
+    direction.x = Direction$1.Forward;
     speed.x = acceleration * Math.abs((scrollContainerRect.right - threshold.width - right) / threshold.width);
   } else if (!isLeft && left <= scrollContainerRect.left + threshold.width) {
-    direction.x = Direction.Backward;
+    direction.x = Direction$1.Backward;
     speed.x = acceleration * Math.abs((scrollContainerRect.left + threshold.width - left) / threshold.width);
   }
   return {
@@ -919,7 +919,7 @@ function getScrollElementRect(element2) {
 function getScrollOffsets(scrollableAncestors) {
   return scrollableAncestors.reduce((acc, node2) => {
     return add(acc, getScrollCoordinates(node2));
-  }, defaultCoordinates);
+  }, defaultCoordinates$1);
 }
 function getScrollXOffset(scrollableAncestors) {
   return scrollableAncestors.reduce((acc, node2) => {
@@ -1030,7 +1030,7 @@ function hasExceededDistance(delta, measurement) {
   }
   return false;
 }
-var EventName;
+var EventName$1;
 (function(EventName2) {
   EventName2["Click"] = "click";
   EventName2["DragStart"] = "dragstart";
@@ -1039,14 +1039,14 @@ var EventName;
   EventName2["Resize"] = "resize";
   EventName2["SelectionChange"] = "selectionchange";
   EventName2["VisibilityChange"] = "visibilitychange";
-})(EventName || (EventName = {}));
+})(EventName$1 || (EventName$1 = {}));
 function preventDefault(event) {
   event.preventDefault();
 }
 function stopPropagation(event) {
   event.stopPropagation();
 }
-var KeyboardCode;
+var KeyboardCode$1;
 (function(KeyboardCode2) {
   KeyboardCode2["Space"] = "Space";
   KeyboardCode2["Down"] = "ArrowDown";
@@ -1056,33 +1056,33 @@ var KeyboardCode;
   KeyboardCode2["Esc"] = "Escape";
   KeyboardCode2["Enter"] = "Enter";
   KeyboardCode2["Tab"] = "Tab";
-})(KeyboardCode || (KeyboardCode = {}));
+})(KeyboardCode$1 || (KeyboardCode$1 = {}));
 const defaultKeyboardCodes = {
-  start: [KeyboardCode.Space, KeyboardCode.Enter],
-  cancel: [KeyboardCode.Esc],
-  end: [KeyboardCode.Space, KeyboardCode.Enter, KeyboardCode.Tab]
+  start: [KeyboardCode$1.Space, KeyboardCode$1.Enter],
+  cancel: [KeyboardCode$1.Esc],
+  end: [KeyboardCode$1.Space, KeyboardCode$1.Enter, KeyboardCode$1.Tab]
 };
 const defaultKeyboardCoordinateGetter = (event, _ref) => {
   let {
     currentCoordinates
   } = _ref;
   switch (event.code) {
-    case KeyboardCode.Right:
+    case KeyboardCode$1.Right:
       return {
         ...currentCoordinates,
         x: currentCoordinates.x + 25
       };
-    case KeyboardCode.Left:
+    case KeyboardCode$1.Left:
       return {
         ...currentCoordinates,
         x: currentCoordinates.x - 25
       };
-    case KeyboardCode.Down:
+    case KeyboardCode$1.Down:
       return {
         ...currentCoordinates,
         y: currentCoordinates.y + 25
       };
-    case KeyboardCode.Up:
+    case KeyboardCode$1.Up:
       return {
         ...currentCoordinates,
         y: currentCoordinates.y - 25
@@ -1112,9 +1112,9 @@ class KeyboardSensor {
   }
   attach() {
     this.handleStart();
-    this.windowListeners.add(EventName.Resize, this.handleCancel);
-    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);
-    setTimeout(() => this.listeners.add(EventName.Keydown, this.handleKeyDown));
+    this.windowListeners.add(EventName$1.Resize, this.handleCancel);
+    this.windowListeners.add(EventName$1.VisibilityChange, this.handleCancel);
+    setTimeout(() => this.listeners.add(EventName$1.Keydown, this.handleKeyDown));
   }
   handleStart() {
     const {
@@ -1125,7 +1125,7 @@ class KeyboardSensor {
     if (node2) {
       scrollIntoViewIfNeeded(node2);
     }
-    onStart(defaultCoordinates);
+    onStart(defaultCoordinates$1);
   }
   handleKeyDown(event) {
     if (isKeyboardEvent(event)) {
@@ -1156,7 +1156,7 @@ class KeyboardSensor {
       const currentCoordinates = collisionRect ? {
         x: collisionRect.left,
         y: collisionRect.top
-      } : defaultCoordinates;
+      } : defaultCoordinates$1;
       if (!this.referenceCoordinates) {
         this.referenceCoordinates = currentCoordinates;
       }
@@ -1186,14 +1186,14 @@ class KeyboardSensor {
           } = getScrollPosition(scrollContainer);
           const scrollElementRect = getScrollElementRect(scrollContainer);
           const clampedCoordinates = {
-            x: Math.min(direction === KeyboardCode.Right ? scrollElementRect.right - scrollElementRect.width / 2 : scrollElementRect.right, Math.max(direction === KeyboardCode.Right ? scrollElementRect.left : scrollElementRect.left + scrollElementRect.width / 2, newCoordinates.x)),
-            y: Math.min(direction === KeyboardCode.Down ? scrollElementRect.bottom - scrollElementRect.height / 2 : scrollElementRect.bottom, Math.max(direction === KeyboardCode.Down ? scrollElementRect.top : scrollElementRect.top + scrollElementRect.height / 2, newCoordinates.y))
+            x: Math.min(direction === KeyboardCode$1.Right ? scrollElementRect.right - scrollElementRect.width / 2 : scrollElementRect.right, Math.max(direction === KeyboardCode$1.Right ? scrollElementRect.left : scrollElementRect.left + scrollElementRect.width / 2, newCoordinates.x)),
+            y: Math.min(direction === KeyboardCode$1.Down ? scrollElementRect.bottom - scrollElementRect.height / 2 : scrollElementRect.bottom, Math.max(direction === KeyboardCode$1.Down ? scrollElementRect.top : scrollElementRect.top + scrollElementRect.height / 2, newCoordinates.y))
           };
-          const canScrollX = direction === KeyboardCode.Right && !isRight || direction === KeyboardCode.Left && !isLeft;
-          const canScrollY = direction === KeyboardCode.Down && !isBottom || direction === KeyboardCode.Up && !isTop;
+          const canScrollX = direction === KeyboardCode$1.Right && !isRight || direction === KeyboardCode$1.Left && !isLeft;
+          const canScrollY = direction === KeyboardCode$1.Down && !isBottom || direction === KeyboardCode$1.Up && !isTop;
           if (canScrollX && clampedCoordinates.x !== newCoordinates.x) {
             const newScrollCoordinates = scrollContainer.scrollLeft + coordinatesDelta.x;
-            const canScrollToNewCoordinates = direction === KeyboardCode.Right && newScrollCoordinates <= maxScroll.x || direction === KeyboardCode.Left && newScrollCoordinates >= minScroll.x;
+            const canScrollToNewCoordinates = direction === KeyboardCode$1.Right && newScrollCoordinates <= maxScroll.x || direction === KeyboardCode$1.Left && newScrollCoordinates >= minScroll.x;
             if (canScrollToNewCoordinates && !coordinatesDelta.y) {
               scrollContainer.scrollTo({
                 left: newScrollCoordinates,
@@ -1204,7 +1204,7 @@ class KeyboardSensor {
             if (canScrollToNewCoordinates) {
               scrollDelta.x = scrollContainer.scrollLeft - newScrollCoordinates;
             } else {
-              scrollDelta.x = direction === KeyboardCode.Right ? scrollContainer.scrollLeft - maxScroll.x : scrollContainer.scrollLeft - minScroll.x;
+              scrollDelta.x = direction === KeyboardCode$1.Right ? scrollContainer.scrollLeft - maxScroll.x : scrollContainer.scrollLeft - minScroll.x;
             }
             if (scrollDelta.x) {
               scrollContainer.scrollBy({
@@ -1215,7 +1215,7 @@ class KeyboardSensor {
             break;
           } else if (canScrollY && clampedCoordinates.y !== newCoordinates.y) {
             const newScrollCoordinates = scrollContainer.scrollTop + coordinatesDelta.y;
-            const canScrollToNewCoordinates = direction === KeyboardCode.Down && newScrollCoordinates <= maxScroll.y || direction === KeyboardCode.Up && newScrollCoordinates >= minScroll.y;
+            const canScrollToNewCoordinates = direction === KeyboardCode$1.Down && newScrollCoordinates <= maxScroll.y || direction === KeyboardCode$1.Up && newScrollCoordinates >= minScroll.y;
             if (canScrollToNewCoordinates && !coordinatesDelta.x) {
               scrollContainer.scrollTo({
                 top: newScrollCoordinates,
@@ -1226,7 +1226,7 @@ class KeyboardSensor {
             if (canScrollToNewCoordinates) {
               scrollDelta.y = scrollContainer.scrollTop - newScrollCoordinates;
             } else {
-              scrollDelta.y = direction === KeyboardCode.Down ? scrollContainer.scrollTop - maxScroll.y : scrollContainer.scrollTop - minScroll.y;
+              scrollDelta.y = direction === KeyboardCode$1.Down ? scrollContainer.scrollTop - maxScroll.y : scrollContainer.scrollTop - minScroll.y;
             }
             if (scrollDelta.y) {
               scrollContainer.scrollBy({
@@ -1332,7 +1332,7 @@ class AbstractPointerSensor {
     this.documentListeners = new Listeners(this.document);
     this.listeners = new Listeners(listenerTarget);
     this.windowListeners = new Listeners(getWindow(target));
-    this.initialCoordinates = (_getEventCoordinates = getEventCoordinates(event)) != null ? _getEventCoordinates : defaultCoordinates;
+    this.initialCoordinates = (_getEventCoordinates = getEventCoordinates(event)) != null ? _getEventCoordinates : defaultCoordinates$1;
     this.handleStart = this.handleStart.bind(this);
     this.handleMove = this.handleMove.bind(this);
     this.handleEnd = this.handleEnd.bind(this);
@@ -1358,11 +1358,11 @@ class AbstractPointerSensor {
     if (events2.cancel) {
       this.listeners.add(events2.cancel.name, this.handleCancel);
     }
-    this.windowListeners.add(EventName.Resize, this.handleCancel);
-    this.windowListeners.add(EventName.DragStart, preventDefault);
-    this.windowListeners.add(EventName.VisibilityChange, this.handleCancel);
-    this.windowListeners.add(EventName.ContextMenu, preventDefault);
-    this.documentListeners.add(EventName.Keydown, this.handleKeydown);
+    this.windowListeners.add(EventName$1.Resize, this.handleCancel);
+    this.windowListeners.add(EventName$1.DragStart, preventDefault);
+    this.windowListeners.add(EventName$1.VisibilityChange, this.handleCancel);
+    this.windowListeners.add(EventName$1.ContextMenu, preventDefault);
+    this.documentListeners.add(EventName$1.Keydown, this.handleKeydown);
     if (activationConstraint) {
       if (bypassActivationConstraint != null && bypassActivationConstraint({
         event: this.props.event,
@@ -1408,11 +1408,11 @@ class AbstractPointerSensor {
     } = this.props;
     if (initialCoordinates) {
       this.activated = true;
-      this.documentListeners.add(EventName.Click, stopPropagation, {
+      this.documentListeners.add(EventName$1.Click, stopPropagation, {
         capture: true
       });
       this.removeTextSelection();
-      this.documentListeners.add(EventName.SelectionChange, this.removeTextSelection);
+      this.documentListeners.add(EventName$1.SelectionChange, this.removeTextSelection);
       onStart(initialCoordinates);
     }
   }
@@ -1432,7 +1432,7 @@ class AbstractPointerSensor {
     if (!initialCoordinates) {
       return;
     }
-    const coordinates = (_getEventCoordinates2 = getEventCoordinates(event)) != null ? _getEventCoordinates2 : defaultCoordinates;
+    const coordinates = (_getEventCoordinates2 = getEventCoordinates(event)) != null ? _getEventCoordinates2 : defaultCoordinates$1;
     const delta = subtract(initialCoordinates, coordinates);
     if (!activated && activationConstraint) {
       if (isDistanceConstraint(activationConstraint)) {
@@ -1479,7 +1479,7 @@ class AbstractPointerSensor {
     onCancel();
   }
   handleKeydown(event) {
-    if (event.code === KeyboardCode.Esc) {
+    if (event.code === KeyboardCode$1.Esc) {
       this.handleCancel();
     }
   }
@@ -1534,10 +1534,10 @@ const events$1 = {
     name: "mouseup"
   }
 };
-var MouseButton;
+var MouseButton$1;
 (function(MouseButton2) {
   MouseButton2[MouseButton2["RightClick"] = 2] = "RightClick";
-})(MouseButton || (MouseButton = {}));
+})(MouseButton$1 || (MouseButton$1 = {}));
 class MouseSensor extends AbstractPointerSensor {
   constructor(props) {
     super(props, events$1, getOwnerDocument(props.event.target));
@@ -1552,7 +1552,7 @@ MouseSensor.activators = [{
     let {
       onActivation
     } = _ref2;
-    if (event.button === MouseButton.RightClick) {
+    if (event.button === MouseButton$1.RightClick) {
       return false;
     }
     onActivation == null ? void 0 : onActivation({
@@ -1609,25 +1609,25 @@ TouchSensor.activators = [{
     return true;
   }
 }];
-var AutoScrollActivator;
+var AutoScrollActivator$1;
 (function(AutoScrollActivator2) {
   AutoScrollActivator2[AutoScrollActivator2["Pointer"] = 0] = "Pointer";
   AutoScrollActivator2[AutoScrollActivator2["DraggableRect"] = 1] = "DraggableRect";
-})(AutoScrollActivator || (AutoScrollActivator = {}));
-var TraversalOrder;
+})(AutoScrollActivator$1 || (AutoScrollActivator$1 = {}));
+var TraversalOrder$1;
 (function(TraversalOrder2) {
   TraversalOrder2[TraversalOrder2["TreeOrder"] = 0] = "TreeOrder";
   TraversalOrder2[TraversalOrder2["ReversedTreeOrder"] = 1] = "ReversedTreeOrder";
-})(TraversalOrder || (TraversalOrder = {}));
+})(TraversalOrder$1 || (TraversalOrder$1 = {}));
 function useAutoScroller(_ref) {
   let {
     acceleration,
-    activator = AutoScrollActivator.Pointer,
+    activator = AutoScrollActivator$1.Pointer,
     canScroll,
     draggingRect,
     enabled,
     interval = 5,
-    order: order2 = TraversalOrder.TreeOrder,
+    order: order2 = TraversalOrder$1.TreeOrder,
     pointerCoordinates,
     scrollableAncestors,
     scrollableAncestorRects,
@@ -1649,14 +1649,14 @@ function useAutoScroller(_ref) {
   });
   const rect = useMemo(() => {
     switch (activator) {
-      case AutoScrollActivator.Pointer:
+      case AutoScrollActivator$1.Pointer:
         return pointerCoordinates ? {
           top: pointerCoordinates.y,
           bottom: pointerCoordinates.y,
           left: pointerCoordinates.x,
           right: pointerCoordinates.x
         } : null;
-      case AutoScrollActivator.DraggableRect:
+      case AutoScrollActivator$1.DraggableRect:
         return draggingRect;
     }
   }, [activator, draggingRect, pointerCoordinates]);
@@ -1670,7 +1670,7 @@ function useAutoScroller(_ref) {
     const scrollTop = scrollSpeed.current.y * scrollDirection.current.y;
     scrollContainer.scrollBy(scrollLeft, scrollTop);
   }, []);
-  const sortedScrollableAncestors = useMemo(() => order2 === TraversalOrder.TreeOrder ? [...scrollableAncestors].reverse() : scrollableAncestors, [order2, scrollableAncestors]);
+  const sortedScrollableAncestors = useMemo(() => order2 === TraversalOrder$1.TreeOrder ? [...scrollableAncestors].reverse() : scrollableAncestors, [order2, scrollableAncestors]);
   useEffect(
     () => {
       if (!enabled || !scrollableAncestors.length || !rect) {
@@ -1738,12 +1738,12 @@ function useAutoScroller(_ref) {
 }
 const defaultScrollIntent = {
   x: {
-    [Direction.Backward]: false,
-    [Direction.Forward]: false
+    [Direction$1.Backward]: false,
+    [Direction$1.Forward]: false
   },
   y: {
-    [Direction.Backward]: false,
-    [Direction.Forward]: false
+    [Direction$1.Backward]: false,
+    [Direction$1.Forward]: false
   }
 };
 function useScrollIntent(_ref2) {
@@ -1762,12 +1762,12 @@ function useScrollIntent(_ref2) {
     };
     return {
       x: {
-        [Direction.Backward]: previousIntent.x[Direction.Backward] || direction.x === -1,
-        [Direction.Forward]: previousIntent.x[Direction.Forward] || direction.x === 1
+        [Direction$1.Backward]: previousIntent.x[Direction$1.Backward] || direction.x === -1,
+        [Direction$1.Forward]: previousIntent.x[Direction$1.Forward] || direction.x === 1
       },
       y: {
-        [Direction.Backward]: previousIntent.y[Direction.Backward] || direction.y === -1,
-        [Direction.Forward]: previousIntent.y[Direction.Forward] || direction.y === 1
+        [Direction$1.Backward]: previousIntent.y[Direction$1.Backward] || direction.y === -1,
+        [Direction$1.Forward]: previousIntent.y[Direction$1.Forward] || direction.y === 1
       }
     };
   }, [disabled, delta, previousDelta]);
@@ -1795,16 +1795,16 @@ function useCombineActivators(sensors, getSyntheticHandler) {
     return [...accumulator, ...sensorActivators];
   }, []), [sensors, getSyntheticHandler]);
 }
-var MeasuringStrategy;
+var MeasuringStrategy$1;
 (function(MeasuringStrategy2) {
   MeasuringStrategy2[MeasuringStrategy2["Always"] = 0] = "Always";
   MeasuringStrategy2[MeasuringStrategy2["BeforeDragging"] = 1] = "BeforeDragging";
   MeasuringStrategy2[MeasuringStrategy2["WhileDragging"] = 2] = "WhileDragging";
-})(MeasuringStrategy || (MeasuringStrategy = {}));
-var MeasuringFrequency;
+})(MeasuringStrategy$1 || (MeasuringStrategy$1 = {}));
+var MeasuringFrequency$1;
 (function(MeasuringFrequency2) {
   MeasuringFrequency2["Optimized"] = "optimized";
-})(MeasuringFrequency || (MeasuringFrequency = {}));
+})(MeasuringFrequency$1 || (MeasuringFrequency$1 = {}));
 const defaultValue = /* @__PURE__ */ new Map();
 function useDroppableMeasuring(containers, _ref) {
   let {
@@ -1903,9 +1903,9 @@ function useDroppableMeasuring(containers, _ref) {
   };
   function isDisabled() {
     switch (strategy) {
-      case MeasuringStrategy.Always:
+      case MeasuringStrategy$1.Always:
         return false;
-      case MeasuringStrategy.BeforeDragging:
+      case MeasuringStrategy$1.BeforeDragging:
         return dragging;
       default:
         return !dragging;
@@ -2096,9 +2096,9 @@ function useScrollOffsets(elements) {
   }, [handleScroll, elements]);
   return useMemo(() => {
     if (elements.length) {
-      return scrollCoordinates ? Array.from(scrollCoordinates.values()).reduce((acc, coordinates) => add(acc, coordinates), defaultCoordinates) : getScrollOffsets(elements);
+      return scrollCoordinates ? Array.from(scrollCoordinates.values()).reduce((acc, coordinates) => add(acc, coordinates), defaultCoordinates$1) : getScrollOffsets(elements);
     }
-    return defaultCoordinates;
+    return defaultCoordinates$1;
   }, [elements, scrollCoordinates]);
 }
 function useScrollOffsetsDelta(scrollOffsets, dependencies) {
@@ -2114,7 +2114,7 @@ function useScrollOffsetsDelta(scrollOffsets, dependencies) {
     dependencies
   );
   useEffect(() => {
-    const hasScrollOffsets = scrollOffsets !== defaultCoordinates;
+    const hasScrollOffsets = scrollOffsets !== defaultCoordinates$1;
     if (hasScrollOffsets && !initialScrollOffsets.current) {
       initialScrollOffsets.current = scrollOffsets;
     }
@@ -2122,7 +2122,7 @@ function useScrollOffsetsDelta(scrollOffsets, dependencies) {
       initialScrollOffsets.current = null;
     }
   }, [scrollOffsets]);
-  return initialScrollOffsets.current ? subtract(scrollOffsets, initialScrollOffsets.current) : defaultCoordinates;
+  return initialScrollOffsets.current ? subtract(scrollOffsets, initialScrollOffsets.current) : defaultCoordinates$1;
 }
 function useSensorSetup(sensors) {
   useEffect(
@@ -2261,8 +2261,8 @@ const defaultMeasuringConfiguration = {
   },
   droppable: {
     measure: getTransformAgnosticClientRect,
-    strategy: MeasuringStrategy.WhileDragging,
-    frequency: MeasuringFrequency.Optimized
+    strategy: MeasuringStrategy$1.WhileDragging,
+    frequency: MeasuringFrequency$1.Optimized
   },
   dragOverlay: {
     measure: getClientRect
@@ -2350,7 +2350,7 @@ function getInitialState() {
 }
 function reducer(state, action) {
   switch (action.type) {
-    case Action.DragStart:
+    case Action$1.DragStart:
       return {
         ...state,
         draggable: {
@@ -2359,7 +2359,7 @@ function reducer(state, action) {
           active: action.active
         }
       };
-    case Action.DragMove:
+    case Action$1.DragMove:
       if (state.draggable.active == null) {
         return state;
       }
@@ -2373,8 +2373,8 @@ function reducer(state, action) {
           }
         }
       };
-    case Action.DragEnd:
-    case Action.DragCancel:
+    case Action$1.DragEnd:
+    case Action$1.DragCancel:
       return {
         ...state,
         draggable: {
@@ -2390,7 +2390,7 @@ function reducer(state, action) {
           }
         }
       };
-    case Action.RegisterDroppable: {
+    case Action$1.RegisterDroppable: {
       const {
         element: element2
       } = action;
@@ -2407,7 +2407,7 @@ function reducer(state, action) {
         }
       };
     }
-    case Action.SetDroppableDisabled: {
+    case Action$1.SetDroppableDisabled: {
       const {
         id,
         key: key2,
@@ -2430,7 +2430,7 @@ function reducer(state, action) {
         }
       };
     }
-    case Action.UnregisterDroppable: {
+    case Action$1.UnregisterDroppable: {
       const {
         id,
         key: key2
@@ -2584,16 +2584,16 @@ function useLayoutShiftScrollCompensation(_ref) {
   }, [activeNode, x, y, initialRect, measure]);
 }
 const ActiveDraggableContext = /* @__PURE__ */ createContext({
-  ...defaultCoordinates,
+  ...defaultCoordinates$1,
   scaleX: 1,
   scaleY: 1
 });
-var Status;
+var Status$1;
 (function(Status2) {
   Status2[Status2["Uninitialized"] = 0] = "Uninitialized";
   Status2[Status2["Initializing"] = 1] = "Initializing";
   Status2[Status2["Initialized"] = 2] = "Initialized";
-})(Status || (Status = {}));
+})(Status$1 || (Status$1 = {}));
 const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
   var _sensorContext$curren, _dragOverlay$nodeRef$, _dragOverlay$rect, _over$rect;
   let {
@@ -2610,8 +2610,8 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
   const store = useReducer(reducer, void 0, getInitialState);
   const [state, dispatch] = store;
   const [dispatchMonitorEvent, registerMonitorListener] = useDndMonitorProvider();
-  const [status, setStatus] = useState(Status.Uninitialized);
-  const isInitialized = status === Status.Initialized;
+  const [status, setStatus] = useState(Status$1.Uninitialized);
+  const isInitialized = status === Status$1.Initialized;
   const {
     draggable: {
       active: activeId,
@@ -2807,9 +2807,9 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
           };
           unstable_batchedUpdates(() => {
             onDragStart == null ? void 0 : onDragStart(event2);
-            setStatus(Status.Initializing);
+            setStatus(Status$1.Initializing);
             dispatch({
-              type: Action.DragStart,
+              type: Action$1.DragStart,
               initialCoordinates,
               active: id2
             });
@@ -2823,12 +2823,12 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
         },
         onMove(coordinates) {
           dispatch({
-            type: Action.DragMove,
+            type: Action$1.DragMove,
             coordinates
           });
         },
-        onEnd: createHandler(Action.DragEnd),
-        onCancel: createHandler(Action.DragCancel)
+        onEnd: createHandler(Action$1.DragEnd),
+        onCancel: createHandler(Action$1.DragCancel)
       });
       activeSensorRef.current = sensorInstance;
       function createHandler(type) {
@@ -2851,10 +2851,10 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
               delta: scrollAdjustedTranslate2,
               over: over2
             };
-            if (type === Action.DragEnd && typeof cancelDrop === "function") {
+            if (type === Action$1.DragEnd && typeof cancelDrop === "function") {
               const shouldCancel = await Promise.resolve(cancelDrop(event2));
               if (shouldCancel) {
-                type = Action.DragCancel;
+                type = Action$1.DragCancel;
               }
             }
           }
@@ -2863,12 +2863,12 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
             dispatch({
               type
             });
-            setStatus(Status.Uninitialized);
+            setStatus(Status$1.Uninitialized);
             setOver(null);
             setActiveSensor(null);
             setActivatorEvent(null);
             activeSensorRef.current = null;
-            const eventName = type === Action.DragEnd ? "onDragEnd" : "onDragCancel";
+            const eventName = type === Action$1.DragEnd ? "onDragEnd" : "onDragCancel";
             if (event2) {
               const handler2 = latestProps.current[eventName];
               handler2 == null ? void 0 : handler2(event2);
@@ -2912,8 +2912,8 @@ const DndContext = /* @__PURE__ */ memo(function DndContext2(_ref) {
   const activators = useCombineActivators(sensors, bindActivatorToSensorInstantiator);
   useSensorSetup(sensors);
   useIsomorphicLayoutEffect$2(() => {
-    if (activeNodeRect && status === Status.Initializing) {
-      setStatus(Status.Initialized);
+    if (activeNodeRect && status === Status$1.Initializing) {
+      setStatus(Status$1.Initialized);
     }
   }, [activeNodeRect, status]);
   useEffect(
@@ -3245,7 +3245,7 @@ function useDroppable(_ref) {
   useEffect(
     () => {
       dispatch({
-        type: Action.RegisterDroppable,
+        type: Action$1.RegisterDroppable,
         element: {
           id,
           key: key2,
@@ -3256,7 +3256,7 @@ function useDroppable(_ref) {
         }
       });
       return () => dispatch({
-        type: Action.UnregisterDroppable,
+        type: Action$1.UnregisterDroppable,
         key: key2,
         id
       });
@@ -3267,7 +3267,7 @@ function useDroppable(_ref) {
   useEffect(() => {
     if (disabled !== previous2.current.disabled) {
       dispatch({
-        type: Action.SetDroppableDisabled,
+        type: Action$1.SetDroppableDisabled,
         id,
         key: key2,
         disabled
@@ -5755,100 +5755,266 @@ function panelDataHelper$1(panelDataArray, panelData, layout) {
     pivotIndices
   };
 }
-function C$1(e) {
-  return { "--panel-background": e.colors.background, "--panel-border": e.colors.border, "--panel-handle": e.colors.backgroundSecondary, "--panel-handle-hover": e.colors.backgroundHover, "--panel-handle-active": e.colors.primary, "--panel-button-bg": e.colors.surface, "--panel-button-hover": e.colors.backgroundHover, "--panel-button-border": e.colors.border, "--panel-button-icon": e.colors.textSecondary, "--panel-accent-bg": e.colors.primary + "15" };
-}
-const z$1 = forwardRef(({ panels: o, className: a = "", style: s2, theme: d, minPanelWidth: u = 350, idealPanelWidth: p2 = 0.333, showSeparator: h2 = false, onPanelChange: m, preventKeyboardScroll: f = true, disableSwipe: g = false }, v) => {
-  const b = useRef(null), y = useRef(false), w = useRef(null), x = C$1(d);
-  useImperativeHandle(v, () => ({ scrollToPanel: (e) => {
-    if (!b.current) return;
-    const t = b.current, n = t.children[e];
-    if (n) {
-      y.current = true, w.current && clearTimeout(w.current);
-      const e2 = n.offsetLeft;
-      t.scrollTo({ left: e2, behavior: "smooth" }), w.current = setTimeout(() => {
-        y.current = false;
-      }, 500);
+function mapThemeToPanelVars(theme2) {
+  return {
+    "--panel-background": theme2.colors.background,
+    "--panel-border": theme2.colors.border,
+    "--panel-handle": theme2.colors.backgroundSecondary,
+    "--panel-handle-hover": theme2.colors.backgroundHover,
+    "--panel-handle-active": theme2.colors.primary,
+    "--panel-button-bg": theme2.colors.surface,
+    "--panel-button-hover": theme2.colors.backgroundHover,
+    "--panel-button-border": theme2.colors.border,
+    "--panel-button-icon": theme2.colors.textSecondary,
+    "--panel-accent-bg": theme2.colors.primary + "15"
+    // primary color with 15% opacity
+  };
+}
+const SnapCarousel = forwardRef(({
+  panels: panels2,
+  className = "",
+  style: style2,
+  theme: theme2,
+  minPanelWidth = 350,
+  idealPanelWidth = 0.333,
+  // 1/3 of container
+  showSeparator = false,
+  onPanelChange,
+  preventKeyboardScroll = true,
+  disableSwipe = false
+}, ref) => {
+  const containerRef = useRef(null);
+  const isProgrammaticScrollRef = useRef(false);
+  const scrollTimeoutRef = useRef(null);
+  const themeStyles = mapThemeToPanelVars(theme2);
+  useImperativeHandle(ref, () => ({
+    scrollToPanel: (index2) => {
+      if (!containerRef.current) return;
+      const container = containerRef.current;
+      const targetPanel = container.children[index2];
+      if (targetPanel) {
+        isProgrammaticScrollRef.current = true;
+        if (scrollTimeoutRef.current) {
+          clearTimeout(scrollTimeoutRef.current);
+        }
+        const scrollLeft = targetPanel.offsetLeft;
+        container.scrollTo({
+          left: scrollLeft,
+          behavior: "smooth"
+        });
+        scrollTimeoutRef.current = setTimeout(() => {
+          isProgrammaticScrollRef.current = false;
+        }, 500);
+      }
+    },
+    getCurrentPanel: () => {
+      if (!containerRef.current || containerRef.current.children.length === 0) return 0;
+      const container = containerRef.current;
+      const containerRect = container.getBoundingClientRect();
+      const snapPointX = containerRect.left;
+      let closestIndex = 0;
+      let closestDistance = Infinity;
+      for (let i = 0; i < container.children.length; i++) {
+        const panel = container.children[i];
+        const panelRect = panel.getBoundingClientRect();
+        const distance = Math.abs(panelRect.left - snapPointX);
+        if (distance < closestDistance) {
+          closestDistance = distance;
+          closestIndex = i;
+        }
+      }
+      return closestIndex;
     }
-  }, getCurrentPanel: () => {
-    if (!b.current || 0 === b.current.children.length) return 0;
-    const e = b.current, t = e.getBoundingClientRect().left;
-    let n = 0, r2 = 1 / 0;
-    for (let o2 = 0; o2 < e.children.length; o2++) {
-      const i = e.children[o2].getBoundingClientRect(), a2 = Math.abs(i.left - t);
-      a2 < r2 && (r2 = a2, n = o2);
-    }
-    return n;
-  } }));
+  }));
+  const handleScroll = (_e2) => {
+    if (!onPanelChange || !containerRef.current || containerRef.current.children.length === 0) return;
+    if (isProgrammaticScrollRef.current) return;
+    const container = containerRef.current;
+    const containerRect = container.getBoundingClientRect();
+    const snapPointX = containerRect.left;
+    let closestIndex = 0;
+    let closestDistance = Infinity;
+    for (let i = 0; i < container.children.length; i++) {
+      const panel = container.children[i];
+      const panelRect = panel.getBoundingClientRect();
+      const distance = Math.abs(panelRect.left - snapPointX);
+      if (distance < closestDistance) {
+        closestDistance = distance;
+        closestIndex = i;
+      }
+    }
+    onPanelChange(closestIndex);
+  };
   useEffect(() => {
-    if (!f || !b.current) return;
-    const e = b.current, t = (e2) => {
-      const t2 = e2.target;
-      if ("INPUT" === t2.tagName || "TEXTAREA" === t2.tagName || "SELECT" === t2.tagName || t2.isContentEditable || null !== t2.closest(".xterm") || null !== t2.closest('[contenteditable="true"]')) return;
-      [" ", "Space", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "PageUp", "PageDown"].includes(e2.key) && e2.preventDefault();
+    if (!preventKeyboardScroll || !containerRef.current) return;
+    const container = containerRef.current;
+    const handleKeyDown = (e) => {
+      const target = e.target;
+      const isInteractive = target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT" || target.isContentEditable || target.closest(".xterm") !== null || // Terminal elements
+      target.closest('[contenteditable="true"]') !== null;
+      if (isInteractive) {
+        return;
+      }
+      const scrollKeys = [" ", "Space", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "PageUp", "PageDown"];
+      if (scrollKeys.includes(e.key)) {
+        e.preventDefault();
+      }
+    };
+    container.addEventListener("keydown", handleKeyDown);
+    return () => {
+      container.removeEventListener("keydown", handleKeyDown);
     };
-    return e.addEventListener("keydown", t), () => {
-      e.removeEventListener("keydown", t);
+  }, [preventKeyboardScroll]);
+  useEffect(() => {
+    return () => {
+      if (scrollTimeoutRef.current) {
+        clearTimeout(scrollTimeoutRef.current);
+      }
     };
-  }, [f]), useEffect(() => () => {
-    w.current && clearTimeout(w.current);
   }, []);
-  const S = o.length, R = 2 * u;
-  let N;
-  N = 1 === S || 2 === S ? "100%" : `max(${u}px, ${100 * p2}%)`;
-  const E = React2__default.useId().replace(/:/g, "_");
-  return jsxs(Fragment, { children: [
-    2 === S && /* @__PURE__ */ jsx("style", { children: `
-            .snap-carousel-container[data-carousel-id="${E}"][data-panel-count="2"] .snap-carousel-panel {
+  const panelCount = panels2.length;
+  const twoPanelThreshold = minPanelWidth * 2;
+  let panelWidth;
+  if (panelCount === 1) {
+    panelWidth = "100%";
+  } else if (panelCount === 2) {
+    panelWidth = "100%";
+  } else {
+    panelWidth = `max(${minPanelWidth}px, ${idealPanelWidth * 100}%)`;
+  }
+  const carouselId = React2__default.useId().replace(/:/g, "_");
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    panelCount === 2 && /* @__PURE__ */ jsx("style", { children: `
+            .snap-carousel-container[data-carousel-id="${carouselId}"][data-panel-count="2"] .snap-carousel-panel {
               width: 100%;
             }
-            @container (min-width: ${R}px) {
-              .snap-carousel-container[data-carousel-id="${E}"][data-panel-count="2"] .snap-carousel-panel {
+            @container (min-width: ${twoPanelThreshold}px) {
+              .snap-carousel-container[data-carousel-id="${carouselId}"][data-panel-count="2"] .snap-carousel-panel {
                 width: 50%;
               }
             }
           ` }),
-    /* @__PURE__ */ jsx("div", { ref: b, className: `snap-carousel-container ${g ? "swipe-disabled" : ""} ${a}`, style: { ...x, ...s2, "--snap-carousel-min-width": `${u}px`, "--snap-carousel-ideal-width": 100 * p2 + "%", "--snap-carousel-gap": h2 ? "1px" : "0px", "--snap-carousel-panel-width": N, "--snap-carousel-panel-count": S, "--snap-carousel-two-panel-threshold": `${R}px` }, onScroll: (e) => {
-      if (!m || !b.current || 0 === b.current.children.length) return;
-      if (y.current) return;
-      const t = b.current, n = t.getBoundingClientRect().left;
-      let r2 = 0, o2 = 1 / 0;
-      for (let i = 0; i < t.children.length; i++) {
-        const e2 = t.children[i].getBoundingClientRect(), a2 = Math.abs(e2.left - n);
-        a2 < o2 && (o2 = a2, r2 = i);
-      }
-      m(r2);
-    }, "data-panel-count": S, "data-carousel-id": E, children: o.map((t, n) => /* @__PURE__ */ jsx("div", { className: "snap-carousel-panel", children: t }, n)) })
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: containerRef,
+        className: `snap-carousel-container ${disableSwipe ? "swipe-disabled" : ""} ${className}`,
+        style: {
+          ...themeStyles,
+          ...style2,
+          "--snap-carousel-min-width": `${minPanelWidth}px`,
+          "--snap-carousel-ideal-width": `${idealPanelWidth * 100}%`,
+          "--snap-carousel-gap": showSeparator ? "1px" : "0px",
+          "--snap-carousel-panel-width": panelWidth,
+          "--snap-carousel-panel-count": panelCount,
+          "--snap-carousel-two-panel-threshold": `${twoPanelThreshold}px`
+        },
+        onScroll: handleScroll,
+        "data-panel-count": panelCount,
+        "data-carousel-id": carouselId,
+        children: panels2.map((panel, index2) => /* @__PURE__ */ jsx("div", { className: "snap-carousel-panel", children: panel }, index2))
+      }
+    )
   ] });
 });
-z$1.displayName = "SnapCarousel";
-var le$2, se$1;
-(se$1 = le$2 || (le$2 = {})).DragStart = "dragStart", se$1.DragMove = "dragMove", se$1.DragEnd = "dragEnd", se$1.DragCancel = "dragCancel", se$1.DragOver = "dragOver", se$1.RegisterDroppable = "registerDroppable", se$1.SetDroppableDisabled = "setDroppableDisabled", se$1.UnregisterDroppable = "unregisterDroppable";
-const de$1 = /* @__PURE__ */ Object.freeze({ x: 0, y: 0 });
-var Te$1, Ae$1;
-(Ae$1 = Te$1 || (Te$1 = {}))[Ae$1.Forward = 1] = "Forward", Ae$1[Ae$1.Backward = -1] = "Backward";
-var _e$1, je$1, He$1, Ke$1;
-(je$1 = _e$1 || (_e$1 = {})).Click = "click", je$1.DragStart = "dragstart", je$1.Keydown = "keydown", je$1.ContextMenu = "contextmenu", je$1.Resize = "resize", je$1.SelectionChange = "selectionchange", je$1.VisibilityChange = "visibilitychange", (Ke$1 = He$1 || (He$1 = {})).Space = "Space", Ke$1.Down = "ArrowDown", Ke$1.Right = "ArrowRight", Ke$1.Left = "ArrowLeft", Ke$1.Up = "ArrowUp", Ke$1.Esc = "Escape", Ke$1.Enter = "Enter", Ke$1.Tab = "Tab";
-({ start: [He$1.Space, He$1.Enter], cancel: [He$1.Esc], end: [He$1.Space, He$1.Enter, He$1.Tab] });
-var rt$1, ot$1;
-(ot$1 = rt$1 || (rt$1 = {}))[ot$1.RightClick = 2] = "RightClick";
-var at$1, lt$1, st$1, ct$1;
-(lt$1 = at$1 || (at$1 = {}))[lt$1.Pointer = 0] = "Pointer", lt$1[lt$1.DraggableRect = 1] = "DraggableRect", (ct$1 = st$1 || (st$1 = {}))[ct$1.TreeOrder = 0] = "TreeOrder", ct$1[ct$1.ReversedTreeOrder = 1] = "ReversedTreeOrder";
-({ x: { [Te$1.Backward]: false, [Te$1.Forward]: false }, y: { [Te$1.Backward]: false, [Te$1.Forward]: false } });
-var pt$1, ht$1, mt$1;
-(ht$1 = pt$1 || (pt$1 = {}))[ht$1.Always = 0] = "Always", ht$1[ht$1.BeforeDragging = 1] = "BeforeDragging", ht$1[ht$1.WhileDragging = 2] = "WhileDragging", (mt$1 || (mt$1 = {})).Optimized = "optimized";
-({ droppable: { strategy: pt$1.WhileDragging, frequency: mt$1.Optimized } });
-/* @__PURE__ */ createContext({ ...de$1, scaleX: 1, scaleY: 1 });
-var $t$1, Bt$1;
-(Bt$1 = $t$1 || ($t$1 = {}))[Bt$1.Uninitialized = 0] = "Uninitialized", Bt$1[Bt$1.Initializing = 1] = "Initializing", Bt$1[Bt$1.Initialized = 2] = "Initialized";
-var Ut$1;
-(() => {
-  if ("undefined" != typeof window) {
-    const e = window;
-    return e.__principlemd_theme_context__ || (e.__principlemd_theme_context__ = createContext(void 0)), e.__principlemd_theme_context__;
+SnapCarousel.displayName = "SnapCarousel";
+var Action;
+(function(Action2) {
+  Action2["DragStart"] = "dragStart";
+  Action2["DragMove"] = "dragMove";
+  Action2["DragEnd"] = "dragEnd";
+  Action2["DragCancel"] = "dragCancel";
+  Action2["DragOver"] = "dragOver";
+  Action2["RegisterDroppable"] = "registerDroppable";
+  Action2["SetDroppableDisabled"] = "setDroppableDisabled";
+  Action2["UnregisterDroppable"] = "unregisterDroppable";
+})(Action || (Action = {}));
+const defaultCoordinates = /* @__PURE__ */ Object.freeze({
+  x: 0,
+  y: 0
+});
+var Direction;
+(function(Direction2) {
+  Direction2[Direction2["Forward"] = 1] = "Forward";
+  Direction2[Direction2["Backward"] = -1] = "Backward";
+})(Direction || (Direction = {}));
+var EventName;
+(function(EventName2) {
+  EventName2["Click"] = "click";
+  EventName2["DragStart"] = "dragstart";
+  EventName2["Keydown"] = "keydown";
+  EventName2["ContextMenu"] = "contextmenu";
+  EventName2["Resize"] = "resize";
+  EventName2["SelectionChange"] = "selectionchange";
+  EventName2["VisibilityChange"] = "visibilitychange";
+})(EventName || (EventName = {}));
+var KeyboardCode;
+(function(KeyboardCode2) {
+  KeyboardCode2["Space"] = "Space";
+  KeyboardCode2["Down"] = "ArrowDown";
+  KeyboardCode2["Right"] = "ArrowRight";
+  KeyboardCode2["Left"] = "ArrowLeft";
+  KeyboardCode2["Up"] = "ArrowUp";
+  KeyboardCode2["Esc"] = "Escape";
+  KeyboardCode2["Enter"] = "Enter";
+  KeyboardCode2["Tab"] = "Tab";
+})(KeyboardCode || (KeyboardCode = {}));
+({
+  start: [KeyboardCode.Space, KeyboardCode.Enter],
+  cancel: [KeyboardCode.Esc],
+  end: [KeyboardCode.Space, KeyboardCode.Enter, KeyboardCode.Tab]
+});
+var MouseButton;
+(function(MouseButton2) {
+  MouseButton2[MouseButton2["RightClick"] = 2] = "RightClick";
+})(MouseButton || (MouseButton = {}));
+var AutoScrollActivator;
+(function(AutoScrollActivator2) {
+  AutoScrollActivator2[AutoScrollActivator2["Pointer"] = 0] = "Pointer";
+  AutoScrollActivator2[AutoScrollActivator2["DraggableRect"] = 1] = "DraggableRect";
+})(AutoScrollActivator || (AutoScrollActivator = {}));
+var TraversalOrder;
+(function(TraversalOrder2) {
+  TraversalOrder2[TraversalOrder2["TreeOrder"] = 0] = "TreeOrder";
+  TraversalOrder2[TraversalOrder2["ReversedTreeOrder"] = 1] = "ReversedTreeOrder";
+})(TraversalOrder || (TraversalOrder = {}));
+({
+  x: {
+    [Direction.Backward]: false,
+    [Direction.Forward]: false
+  },
+  y: {
+    [Direction.Backward]: false,
+    [Direction.Forward]: false
   }
-  return Ut$1 || (Ut$1 = createContext(void 0)), Ut$1;
-})();
+});
+var MeasuringStrategy;
+(function(MeasuringStrategy2) {
+  MeasuringStrategy2[MeasuringStrategy2["Always"] = 0] = "Always";
+  MeasuringStrategy2[MeasuringStrategy2["BeforeDragging"] = 1] = "BeforeDragging";
+  MeasuringStrategy2[MeasuringStrategy2["WhileDragging"] = 2] = "WhileDragging";
+})(MeasuringStrategy || (MeasuringStrategy = {}));
+var MeasuringFrequency;
+(function(MeasuringFrequency2) {
+  MeasuringFrequency2["Optimized"] = "optimized";
+})(MeasuringFrequency || (MeasuringFrequency = {}));
+({
+  droppable: {
+    strategy: MeasuringStrategy.WhileDragging,
+    frequency: MeasuringFrequency.Optimized
+  }
+});
+/* @__PURE__ */ createContext({
+  ...defaultCoordinates,
+  scaleX: 1,
+  scaleY: 1
+});
+var Status;
+(function(Status2) {
+  Status2[Status2["Uninitialized"] = 0] = "Uninitialized";
+  Status2[Status2["Initializing"] = 1] = "Initializing";
+  Status2[Status2["Initialized"] = 2] = "Initialized";
+})(Status || (Status = {}));
 var Ee = Object.defineProperty;
 var Re = (o, e, t) => e in o ? Ee(o, e, { enumerable: true, configurable: true, writable: true, value: t }) : o[e] = t;
 var le$1 = (o, e, t) => Re(o, typeof e != "symbol" ? e + "" : e, t);
@@ -6336,7 +6502,7 @@ function gt(o, e, t, r2) {
     };
   }, [o, e, t, r2]);
 }
-const version = "1.2.12";
+const version = "1.2.14";
 const packageJson = {
   version
 };
@@ -8777,7 +8943,7 @@ const KanbanPanel = ({
   }));
   const measuringConfig = {
     droppable: {
-      strategy: MeasuringStrategy.Always
+      strategy: MeasuringStrategy$1.Always
     }
   };
   useLayoutEffect(() => {
@@ -54258,7 +54424,7 @@ const TaskDetailPanel = ({
         error: errorMessage
       });
       if (span) {
-        span.addEvent("task.deleted", {
+        span.addEvent("task.delete.failed", {
           "task.id": selectedTask.id
         });
         span.addEvent("task.save.error", {