likec4 1.7.0 → 1.7.1

package/dist/__app__/src/chunks/react-resizable-panels.browser.esm-BaxT8im_.js

@@ -1,1528 +0,0 @@
-import * as React from "react";
-const {
-  createElement,
-  createContext,
-  createRef,
-  forwardRef,
-  useCallback,
-  useContext,
-  useEffect,
-  useImperativeHandle,
-  useLayoutEffect,
-  useMemo,
-  useRef,
-  useState
-} = React, useId = React.useId, useLayoutEffect_do_not_use_directly = useLayoutEffect, PanelGroupContext = createContext(null);
-PanelGroupContext.displayName = "PanelGroupContext";
-const useIsomorphicLayoutEffect = useLayoutEffect_do_not_use_directly, wrappedUseId = typeof useId == "function" ? useId : () => null;
-let counter = 0;
-function useUniqueId(idFromParams = null) {
-  const idFromUseId = wrappedUseId(), idRef = useRef(idFromParams || idFromUseId || null);
-  return idRef.current === null && (idRef.current = "" + counter++), idFromParams ?? idRef.current;
-}
-function PanelWithForwardedRef({
-  children,
-  className: classNameFromProps = "",
-  collapsedSize,
-  collapsible,
-  defaultSize,
-  forwardedRef,
-  id: idFromProps,
-  maxSize,
-  minSize,
-  onCollapse,
-  onExpand,
-  onResize,
-  order,
-  style: styleFromProps,
-  tagName: Type = "div",
-  ...rest
-}) {
-  const context = useContext(PanelGroupContext);
-  if (context === null)
-    throw Error("Panel components must be rendered within a PanelGroup container");
-  const {
-    collapsePanel,
-    expandPanel,
-    getPanelSize,
-    getPanelStyle,
-    groupId,
-    isPanelCollapsed,
-    reevaluatePanelConstraints,
-    registerPanel,
-    resizePanel: resizePanel2,
-    unregisterPanel
-  } = context, panelId = useUniqueId(idFromProps), panelDataRef = useRef({
-    callbacks: {
-      onCollapse,
-      onExpand,
-      onResize
-    },
-    constraints: {
-      collapsedSize,
-      collapsible,
-      defaultSize,
-      maxSize,
-      minSize
-    },
-    id: panelId,
-    idIsFromProps: idFromProps !== void 0,
-    order
-  });
-  useRef({
-    didLogMissingDefaultSizeWarning: !1
-  }), useIsomorphicLayoutEffect(() => {
-    const {
-      callbacks,
-      constraints
-    } = panelDataRef.current, prevConstraints = {
-      ...constraints
-    };
-    panelDataRef.current.id = panelId, panelDataRef.current.idIsFromProps = idFromProps !== void 0, panelDataRef.current.order = order, callbacks.onCollapse =
-    onCollapse, callbacks.onExpand = onExpand, callbacks.onResize = onResize, constraints.collapsedSize = collapsedSize, constraints.collapsible = collapsible,
-    constraints.defaultSize = defaultSize, constraints.maxSize = maxSize, constraints.minSize = minSize, (prevConstraints.collapsedSize !== constraints.
-    collapsedSize || prevConstraints.collapsible !== constraints.collapsible || prevConstraints.maxSize !== constraints.maxSize || prevConstraints.minSize !==
-    constraints.minSize) && reevaluatePanelConstraints(panelDataRef.current, prevConstraints);
-  }), useIsomorphicLayoutEffect(() => {
-    const panelData = panelDataRef.current;
-    return registerPanel(panelData), () => {
-      unregisterPanel(panelData);
-    };
-  }, [order, panelId, registerPanel, unregisterPanel]), useImperativeHandle(forwardedRef, () => ({
-    collapse: () => {
-      collapsePanel(panelDataRef.current);
-    },
-    expand: (minSize2) => {
-      expandPanel(panelDataRef.current, minSize2);
-    },
-    getId() {
-      return panelId;
-    },
-    getSize() {
-      return getPanelSize(panelDataRef.current);
-    },
-    isCollapsed() {
-      return isPanelCollapsed(panelDataRef.current);
-    },
-    isExpanded() {
-      return !isPanelCollapsed(panelDataRef.current);
-    },
-    resize: (size) => {
-      resizePanel2(panelDataRef.current, size);
-    }
-  }), [collapsePanel, expandPanel, getPanelSize, isPanelCollapsed, panelId, resizePanel2]);
-  const style = getPanelStyle(panelDataRef.current, defaultSize);
-  return createElement(Type, {
-    ...rest,
-    children,
-    className: classNameFromProps,
-    id: idFromProps,
-    style: {
-      ...style,
-      ...styleFromProps
-    },
-    // CSS selectors
-    "data-panel": "",
-    "data-panel-collapsible": collapsible || void 0,
-    "data-panel-group-id": groupId,
-    "data-panel-id": panelId,
-    "data-panel-size": parseFloat("" + style.flexGrow).toFixed(1)
-  });
-}
-const Panel = forwardRef((props2, ref) => createElement(PanelWithForwardedRef, {
-  ...props2,
-  forwardedRef: ref
-}));
-PanelWithForwardedRef.displayName = "Panel";
-Panel.displayName = "forwardRef(Panel)";
-let currentCursorStyle = null, styleElement = null;
-function getCursorStyle(state, constraintFlags) {
-  if (constraintFlags) {
-    const horizontalMin = (constraintFlags & EXCEEDED_HORIZONTAL_MIN) !== 0, horizontalMax = (constraintFlags & EXCEEDED_HORIZONTAL_MAX) !== 0, verticalMin = (constraintFlags &
-    EXCEEDED_VERTICAL_MIN) !== 0, verticalMax = (constraintFlags & EXCEEDED_VERTICAL_MAX) !== 0;
-    if (horizontalMin)
-      return verticalMin ? "se-resize" : verticalMax ? "ne-resize" : "e-resize";
-    if (horizontalMax)
-      return verticalMin ? "sw-resize" : verticalMax ? "nw-resize" : "w-resize";
-    if (verticalMin)
-      return "s-resize";
-    if (verticalMax)
-      return "n-resize";
-  }
-  switch (state) {
-    case "horizontal":
-      return "ew-resize";
-    case "intersection":
-      return "move";
-    case "vertical":
-      return "ns-resize";
-  }
-}
-function resetGlobalCursorStyle() {
-  styleElement !== null && (document.head.removeChild(styleElement), currentCursorStyle = null, styleElement = null);
-}
-function setGlobalCursorStyle(state, constraintFlags) {
-  const style = getCursorStyle(state, constraintFlags);
-  currentCursorStyle !== style && (currentCursorStyle = style, styleElement === null && (styleElement = document.createElement("style"), document.head.
-  appendChild(styleElement)), styleElement.innerHTML = `*{cursor: ${style}!important;}`);
-}
-function isKeyDown(event) {
-  return event.type === "keydown";
-}
-function isPointerEvent(event) {
-  return event.type.startsWith("pointer");
-}
-function isMouseEvent(event) {
-  return event.type.startsWith("mouse");
-}
-function getResizeEventCoordinates(event) {
-  if (isPointerEvent(event)) {
-    if (event.isPrimary)
-      return {
-        x: event.clientX,
-        y: event.clientY
-      };
-  } else if (isMouseEvent(event))
-    return {
-      x: event.clientX,
-      y: event.clientY
-    };
-  return {
-    x: 1 / 0,
-    y: 1 / 0
-  };
-}
-function getInputType() {
-  if (typeof matchMedia == "function")
-    return matchMedia("(pointer:coarse)").matches ? "coarse" : "fine";
-}
-function intersects(rectOne, rectTwo, strict) {
-  return rectOne.x < rectTwo.x + rectTwo.width && rectOne.x + rectOne.width > rectTwo.x && rectOne.y < rectTwo.y + rectTwo.height && rectOne.y + rectOne.
-  height > rectTwo.y;
-}
-function compare(a, b) {
-  if (a === b) throw new Error("Cannot compare node with itself");
-  const ancestors = {
-    a: get_ancestors(a),
-    b: get_ancestors(b)
-  };
-  let common_ancestor;
-  for (; ancestors.a.at(-1) === ancestors.b.at(-1); )
-    a = ancestors.a.pop(), b = ancestors.b.pop(), common_ancestor = a;
-  assert(common_ancestor, "Stacking order can only be calculated for elements with a common ancestor");
-  const z_indexes = {
-    a: get_z_index(find_stacking_context(ancestors.a)),
-    b: get_z_index(find_stacking_context(ancestors.b))
-  };
-  if (z_indexes.a === z_indexes.b) {
-    const children = common_ancestor.childNodes, furthest_ancestors = {
-      a: ancestors.a.at(-1),
-      b: ancestors.b.at(-1)
-    };
-    let i = children.length;
-    for (; i--; ) {
-      const child = children[i];
-      if (child === furthest_ancestors.a) return 1;
-      if (child === furthest_ancestors.b) return -1;
-    }
-  }
-  return Math.sign(z_indexes.a - z_indexes.b);
-}
-const props = /\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\b/;
-function is_flex_item(node) {
-  var _get_parent;
-  const display = getComputedStyle((_get_parent = get_parent(node)) !== null && _get_parent !== void 0 ? _get_parent : node).display;
-  return display === "flex" || display === "inline-flex";
-}
-function creates_stacking_context(node) {
-  const style = getComputedStyle(node);
-  return !!(style.position === "fixed" || style.zIndex !== "auto" && (style.position !== "static" || is_flex_item(node)) || +style.opacity < 1 || "tra\
-nsform" in style && style.transform !== "none" || "webkitTransform" in style && style.webkitTransform !== "none" || "mixBlendMode" in style && style.mixBlendMode !==
-  "normal" || "filter" in style && style.filter !== "none" || "webkitFilter" in style && style.webkitFilter !== "none" || "isolation" in style && style.
-  isolation === "isolate" || props.test(style.willChange) || style.webkitOverflowScrolling === "touch");
-}
-function find_stacking_context(nodes) {
-  let i = nodes.length;
-  for (; i--; ) {
-    const node = nodes[i];
-    if (assert(node, "Missing node"), creates_stacking_context(node)) return node;
-  }
-  return null;
-}
-function get_z_index(node) {
-  return node && Number(getComputedStyle(node).zIndex) || 0;
-}
-function get_ancestors(node) {
-  const ancestors = [];
-  for (; node; )
-    ancestors.push(node), node = get_parent(node);
-  return ancestors;
-}
-function get_parent(node) {
-  const {
-    parentNode
-  } = node;
-  return parentNode && parentNode instanceof ShadowRoot ? parentNode.host : parentNode;
-}
-const EXCEEDED_HORIZONTAL_MIN = 1, EXCEEDED_HORIZONTAL_MAX = 2, EXCEEDED_VERTICAL_MIN = 4, EXCEEDED_VERTICAL_MAX = 8, isCoarsePointer = getInputType() ===
-"coarse";
-let intersectingHandles = [], isPointerDown = !1, ownerDocumentCounts = /* @__PURE__ */ new Map(), panelConstraintFlags = /* @__PURE__ */ new Map();
-const registeredResizeHandlers = /* @__PURE__ */ new Set();
-function registerResizeHandle(resizeHandleId, element, direction, hitAreaMargins, setResizeHandlerState) {
-  var _ownerDocumentCounts$;
-  const {
-    ownerDocument
-  } = element, data = {
-    direction,
-    element,
-    hitAreaMargins,
-    setResizeHandlerState
-  }, count = (_ownerDocumentCounts$ = ownerDocumentCounts.get(ownerDocument)) !== null && _ownerDocumentCounts$ !== void 0 ? _ownerDocumentCounts$ : 0;
-  return ownerDocumentCounts.set(ownerDocument, count + 1), registeredResizeHandlers.add(data), updateListeners(), function() {
-    var _ownerDocumentCounts$2;
-    panelConstraintFlags.delete(resizeHandleId), registeredResizeHandlers.delete(data);
-    const count2 = (_ownerDocumentCounts$2 = ownerDocumentCounts.get(ownerDocument)) !== null && _ownerDocumentCounts$2 !== void 0 ? _ownerDocumentCounts$2 :
-    1;
-    if (ownerDocumentCounts.set(ownerDocument, count2 - 1), updateListeners(), count2 === 1 && ownerDocumentCounts.delete(ownerDocument), intersectingHandles.
-    includes(data)) {
-      const index = intersectingHandles.indexOf(data);
-      index >= 0 && intersectingHandles.splice(index, 1), updateCursor();
-    }
-  };
-}
-function handlePointerDown(event) {
-  const {
-    target
-  } = event, {
-    x,
-    y
-  } = getResizeEventCoordinates(event);
-  isPointerDown = !0, recalculateIntersectingHandles({
-    target,
-    x,
-    y
-  }), updateListeners(), intersectingHandles.length > 0 && (updateResizeHandlerStates("down", event), event.preventDefault(), event.stopPropagation());
-}
-function handlePointerMove(event) {
-  const {
-    x,
-    y
-  } = getResizeEventCoordinates(event);
-  if (event.buttons === 0 && (isPointerDown = !1, updateResizeHandlerStates("up", event)), !isPointerDown) {
-    const {
-      target
-    } = event;
-    recalculateIntersectingHandles({
-      target,
-      x,
-      y
-    });
-  }
-  updateResizeHandlerStates("move", event), updateCursor(), intersectingHandles.length > 0 && event.preventDefault();
-}
-function handlePointerUp(event) {
-  const {
-    target
-  } = event, {
-    x,
-    y
-  } = getResizeEventCoordinates(event);
-  panelConstraintFlags.clear(), isPointerDown = !1, intersectingHandles.length > 0 && event.preventDefault(), updateResizeHandlerStates("up", event), recalculateIntersectingHandles(
-  {
-    target,
-    x,
-    y
-  }), updateCursor(), updateListeners();
-}
-function recalculateIntersectingHandles({
-  target,
-  x,
-  y
-}) {
-  intersectingHandles.splice(0);
-  let targetElement = null;
-  target instanceof HTMLElement && (targetElement = target), registeredResizeHandlers.forEach((data) => {
-    const {
-      element: dragHandleElement,
-      hitAreaMargins
-    } = data, dragHandleRect = dragHandleElement.getBoundingClientRect(), {
-      bottom,
-      left,
-      right,
-      top
-    } = dragHandleRect, margin = isCoarsePointer ? hitAreaMargins.coarse : hitAreaMargins.fine;
-    if (x >= left - margin && x <= right + margin && y >= top - margin && y <= bottom + margin) {
-      if (targetElement !== null && dragHandleElement !== targetElement && !dragHandleElement.contains(targetElement) && !targetElement.contains(dragHandleElement) &&
-      // Calculating stacking order has a cost, so we should avoid it if possible
-      // That is why we only check potentially intersecting handles,
-      // and why we skip if the event target is within the handle's DOM
-      compare(targetElement, dragHandleElement) > 0) {
-        let currentElement = targetElement, didIntersect = !1;
-        for (; currentElement && !currentElement.contains(dragHandleElement); ) {
-          if (intersects(currentElement.getBoundingClientRect(), dragHandleRect)) {
-            didIntersect = !0;
-            break;
-          }
-          currentElement = currentElement.parentElement;
-        }
-        if (didIntersect)
-          return;
-      }
-      intersectingHandles.push(data);
-    }
-  });
-}
-function reportConstraintsViolation(resizeHandleId, flag) {
-  panelConstraintFlags.set(resizeHandleId, flag);
-}
-function updateCursor() {
-  let intersectsHorizontal = !1, intersectsVertical = !1;
-  intersectingHandles.forEach((data) => {
-    const {
-      direction
-    } = data;
-    direction === "horizontal" ? intersectsHorizontal = !0 : intersectsVertical = !0;
-  });
-  let constraintFlags = 0;
-  panelConstraintFlags.forEach((flag) => {
-    constraintFlags |= flag;
-  }), intersectsHorizontal && intersectsVertical ? setGlobalCursorStyle("intersection", constraintFlags) : intersectsHorizontal ? setGlobalCursorStyle(
-  "horizontal", constraintFlags) : intersectsVertical ? setGlobalCursorStyle("vertical", constraintFlags) : resetGlobalCursorStyle();
-}
-function updateListeners() {
-  ownerDocumentCounts.forEach((_, ownerDocument) => {
-    const {
-      body
-    } = ownerDocument;
-    body.removeEventListener("contextmenu", handlePointerUp), body.removeEventListener("pointerdown", handlePointerDown), body.removeEventListener("po\
-interleave", handlePointerMove), body.removeEventListener("pointermove", handlePointerMove);
-  }), window.removeEventListener("pointerup", handlePointerUp), window.removeEventListener("pointercancel", handlePointerUp), registeredResizeHandlers.
-  size > 0 && (isPointerDown ? (intersectingHandles.length > 0 && ownerDocumentCounts.forEach((count, ownerDocument) => {
-    const {
-      body
-    } = ownerDocument;
-    count > 0 && (body.addEventListener("contextmenu", handlePointerUp), body.addEventListener("pointerleave", handlePointerMove), body.addEventListener(
-    "pointermove", handlePointerMove));
-  }), window.addEventListener("pointerup", handlePointerUp), window.addEventListener("pointercancel", handlePointerUp)) : ownerDocumentCounts.forEach(
-  (count, ownerDocument) => {
-    const {
-      body
-    } = ownerDocument;
-    count > 0 && (body.addEventListener("pointerdown", handlePointerDown, {
-      capture: !0
-    }), body.addEventListener("pointermove", handlePointerMove));
-  }));
-}
-function updateResizeHandlerStates(action, event) {
-  registeredResizeHandlers.forEach((data) => {
-    const {
-      setResizeHandlerState
-    } = data, isActive = intersectingHandles.includes(data);
-    setResizeHandlerState(action, isActive, event);
-  });
-}
-function useForceUpdate() {
-  const [_, setCount] = useState(0);
-  return useCallback(() => setCount((prevCount) => prevCount + 1), []);
-}
-function assert(expectedCondition, message) {
-  if (!expectedCondition)
-    throw console.error(message), Error(message);
-}
-const PRECISION = 10;
-function fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {
-  return actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits) ? 0 : actual > expected ? 1 : -1;
-}
-function fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {
-  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
-}
-function fuzzyNumbersEqual(actual, expected, fractionDigits) {
-  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;
-}
-function fuzzyLayoutsEqual(actual, expected, fractionDigits) {
-  if (actual.length !== expected.length)
-    return !1;
-  for (let index = 0; index < actual.length; index++) {
-    const actualSize = actual[index], expectedSize = expected[index];
-    if (!fuzzyNumbersEqual(actualSize, expectedSize, fractionDigits))
-      return !1;
-  }
-  return !0;
-}
-function resizePanel({
-  panelConstraints: panelConstraintsArray,
-  panelIndex,
-  size
-}) {
-  const panelConstraints = panelConstraintsArray[panelIndex];
-  assert(panelConstraints != null, `Panel constraints not found for index ${panelIndex}`);
-  let {
-    collapsedSize = 0,
-    collapsible,
-    maxSize = 100,
-    minSize = 0
-  } = panelConstraints;
-  if (fuzzyCompareNumbers(size, minSize) < 0)
-    if (collapsible) {
-      const halfwayPoint = (collapsedSize + minSize) / 2;
-      fuzzyCompareNumbers(size, halfwayPoint) < 0 ? size = collapsedSize : size = minSize;
-    } else
-      size = minSize;
-  return size = Math.min(maxSize, size), size = parseFloat(size.toFixed(PRECISION)), size;
-}
-function adjustLayoutByDelta({
-  delta,
-  initialLayout,
-  panelConstraints: panelConstraintsArray,
-  pivotIndices,
-  prevLayout,
-  trigger
-}) {
-  if (fuzzyNumbersEqual(delta, 0))
-    return initialLayout;
-  const nextLayout = [...initialLayout], [firstPivotIndex, secondPivotIndex] = pivotIndices;
-  assert(firstPivotIndex != null, "Invalid first pivot index"), assert(secondPivotIndex != null, "Invalid second pivot index");
-  let deltaApplied = 0;
-  if (trigger === "keyboard") {
-    {
-      const index = delta < 0 ? secondPivotIndex : firstPivotIndex, panelConstraints = panelConstraintsArray[index];
-      assert(panelConstraints, `Panel constraints not found for index ${index}`);
-      const {
-        collapsedSize = 0,
-        collapsible,
-        minSize = 0
-      } = panelConstraints;
-      if (collapsible) {
-        const prevSize = initialLayout[index];
-        if (assert(prevSize != null, `Previous layout not found for panel index ${index}`), fuzzyNumbersEqual(prevSize, collapsedSize)) {
-          const localDelta = minSize - prevSize;
-          fuzzyCompareNumbers(localDelta, Math.abs(delta)) > 0 && (delta = delta < 0 ? 0 - localDelta : localDelta);
-        }
-      }
-    }
-    {
-      const index = delta < 0 ? firstPivotIndex : secondPivotIndex, panelConstraints = panelConstraintsArray[index];
-      assert(panelConstraints, `No panel constraints found for index ${index}`);
-      const {
-        collapsedSize = 0,
-        collapsible,
-        minSize = 0
-      } = panelConstraints;
-      if (collapsible) {
-        const prevSize = initialLayout[index];
-        if (assert(prevSize != null, `Previous layout not found for panel index ${index}`), fuzzyNumbersEqual(prevSize, minSize)) {
-          const localDelta = prevSize - collapsedSize;
-          fuzzyCompareNumbers(localDelta, Math.abs(delta)) > 0 && (delta = delta < 0 ? 0 - localDelta : localDelta);
-        }
-      }
-    }
-  }
-  {
-    const increment = delta < 0 ? 1 : -1;
-    let index = delta < 0 ? secondPivotIndex : firstPivotIndex, maxAvailableDelta = 0;
-    for (; ; ) {
-      const prevSize = initialLayout[index];
-      assert(prevSize != null, `Previous layout not found for panel index ${index}`);
-      const delta2 = resizePanel({
-        panelConstraints: panelConstraintsArray,
-        panelIndex: index,
-        size: 100
-      }) - prevSize;
-      if (maxAvailableDelta += delta2, index += increment, index < 0 || index >= panelConstraintsArray.length)
-        break;
-    }
-    const minAbsDelta = Math.min(Math.abs(delta), Math.abs(maxAvailableDelta));
-    delta = delta < 0 ? 0 - minAbsDelta : minAbsDelta;
-  }
-  {
-    let index = delta < 0 ? firstPivotIndex : secondPivotIndex;
-    for (; index >= 0 && index < panelConstraintsArray.length; ) {
-      const deltaRemaining = Math.abs(delta) - Math.abs(deltaApplied), prevSize = initialLayout[index];
-      assert(prevSize != null, `Previous layout not found for panel index ${index}`);
-      const unsafeSize = prevSize - deltaRemaining, safeSize = resizePanel({
-        panelConstraints: panelConstraintsArray,
-        panelIndex: index,
-        size: unsafeSize
-      });
-      if (!fuzzyNumbersEqual(prevSize, safeSize) && (deltaApplied += prevSize - safeSize, nextLayout[index] = safeSize, deltaApplied.toPrecision(3).localeCompare(
-      Math.abs(delta).toPrecision(3), void 0, {
-        numeric: !0
-      }) >= 0))
-        break;
-      delta < 0 ? index-- : index++;
-    }
-  }
-  if (fuzzyLayoutsEqual(prevLayout, nextLayout))
-    return prevLayout;
-  {
-    const pivotIndex = delta < 0 ? secondPivotIndex : firstPivotIndex, prevSize = initialLayout[pivotIndex];
-    assert(prevSize != null, `Previous layout not found for panel index ${pivotIndex}`);
-    const unsafeSize = prevSize + deltaApplied, safeSize = resizePanel({
-      panelConstraints: panelConstraintsArray,
-      panelIndex: pivotIndex,
-      size: unsafeSize
-    });
-    if (nextLayout[pivotIndex] = safeSize, !fuzzyNumbersEqual(safeSize, unsafeSize)) {
-      let deltaRemaining = unsafeSize - safeSize, index = delta < 0 ? secondPivotIndex : firstPivotIndex;
-      for (; index >= 0 && index < panelConstraintsArray.length; ) {
-        const prevSize2 = nextLayout[index];
-        assert(prevSize2 != null, `Previous layout not found for panel index ${index}`);
-        const unsafeSize2 = prevSize2 + deltaRemaining, safeSize2 = resizePanel({
-          panelConstraints: panelConstraintsArray,
-          panelIndex: index,
-          size: unsafeSize2
-        });
-        if (fuzzyNumbersEqual(prevSize2, safeSize2) || (deltaRemaining -= safeSize2 - prevSize2, nextLayout[index] = safeSize2), fuzzyNumbersEqual(deltaRemaining,
-        0))
-          break;
-        delta > 0 ? index-- : index++;
-      }
-    }
-  }
-  const totalSize = nextLayout.reduce((total, size) => size + total, 0);
-  return fuzzyNumbersEqual(totalSize, 100) ? nextLayout : prevLayout;
-}
-function calculateAriaValues({
-  layout,
-  panelsArray,
-  pivotIndices
-}) {
-  let currentMinSize = 0, currentMaxSize = 100, totalMinSize = 0, totalMaxSize = 0;
-  const firstIndex = pivotIndices[0];
-  assert(firstIndex != null, "No pivot index found"), panelsArray.forEach((panelData, index) => {
-    const {
-      constraints
-    } = panelData, {
-      maxSize = 100,
-      minSize = 0
-    } = constraints;
-    index === firstIndex ? (currentMinSize = minSize, currentMaxSize = maxSize) : (totalMinSize += minSize, totalMaxSize += maxSize);
-  });
-  const valueMax = Math.min(currentMaxSize, 100 - totalMinSize), valueMin = Math.max(currentMinSize, 100 - totalMaxSize), valueNow = layout[firstIndex];
-  return {
-    valueMax,
-    valueMin,
-    valueNow
-  };
-}
-function getResizeHandleElementsForGroup(groupId, scope = document) {
-  return Array.from(scope.querySelectorAll(`[data-panel-resize-handle-id][data-panel-group-id="${groupId}"]`));
-}
-function getResizeHandleElementIndex(groupId, id, scope = document) {
-  const index = getResizeHandleElementsForGroup(groupId, scope).findIndex((handle) => handle.getAttribute("data-panel-resize-handle-id") === id);
-  return index ?? null;
-}
-function determinePivotIndices(groupId, dragHandleId, panelGroupElement) {
-  const index = getResizeHandleElementIndex(groupId, dragHandleId, panelGroupElement);
-  return index != null ? [index, index + 1] : [-1, -1];
-}
-function getPanelGroupElement(id, rootElement = document) {
-  var _dataset;
-  if (rootElement instanceof HTMLElement && (rootElement == null || (_dataset = rootElement.dataset) === null || _dataset === void 0 ? void 0 : _dataset.
-  panelGroupId) == id)
-    return rootElement;
-  const element = rootElement.querySelector(`[data-panel-group][data-panel-group-id="${id}"]`);
-  return element || null;
-}
-function getResizeHandleElement(id, scope = document) {
-  const element = scope.querySelector(`[data-panel-resize-handle-id="${id}"]`);
-  return element || null;
-}
-function getResizeHandlePanelIds(groupId, handleId, panelsArray, scope = document) {
-  var _panelsArray$index$id, _panelsArray$index, _panelsArray$id, _panelsArray;
-  const handle = getResizeHandleElement(handleId, scope), handles = getResizeHandleElementsForGroup(groupId, scope), index = handle ? handles.indexOf(
-  handle) : -1, idBefore = (_panelsArray$index$id = (_panelsArray$index = panelsArray[index]) === null || _panelsArray$index === void 0 ? void 0 : _panelsArray$index.
-  id) !== null && _panelsArray$index$id !== void 0 ? _panelsArray$index$id : null, idAfter = (_panelsArray$id = (_panelsArray = panelsArray[index + 1]) ===
-  null || _panelsArray === void 0 ? void 0 : _panelsArray.id) !== null && _panelsArray$id !== void 0 ? _panelsArray$id : null;
-  return [idBefore, idAfter];
-}
-function useWindowSplitterPanelGroupBehavior({
-  committedValuesRef,
-  eagerValuesRef,
-  groupId,
-  layout,
-  panelDataArray,
-  panelGroupElement,
-  setLayout
-}) {
-  useRef({
-    didWarnAboutMissingResizeHandle: !1
-  }), useIsomorphicLayoutEffect(() => {
-    if (!panelGroupElement)
-      return;
-    const resizeHandleElements = getResizeHandleElementsForGroup(groupId, panelGroupElement);
-    for (let index = 0; index < panelDataArray.length - 1; index++) {
-      const {
-        valueMax,
-        valueMin,
-        valueNow
-      } = calculateAriaValues({
-        layout,
-        panelsArray: panelDataArray,
-        pivotIndices: [index, index + 1]
-      }), resizeHandleElement = resizeHandleElements[index];
-      if (resizeHandleElement != null) {
-        const panelData = panelDataArray[index];
-        assert(panelData, `No panel data found for index "${index}"`), resizeHandleElement.setAttribute("aria-controls", panelData.id), resizeHandleElement.
-        setAttribute("aria-valuemax", "" + Math.round(valueMax)), resizeHandleElement.setAttribute("aria-valuemin", "" + Math.round(valueMin)), resizeHandleElement.
-        setAttribute("aria-valuenow", valueNow != null ? "" + Math.round(valueNow) : "");
-      }
-    }
-    return () => {
-      resizeHandleElements.forEach((resizeHandleElement, index) => {
-        resizeHandleElement.removeAttribute("aria-controls"), resizeHandleElement.removeAttribute("aria-valuemax"), resizeHandleElement.removeAttribute(
-        "aria-valuemin"), resizeHandleElement.removeAttribute("aria-valuenow");
-      });
-    };
-  }, [groupId, layout, panelDataArray, panelGroupElement]), useEffect(() => {
-    if (!panelGroupElement)
-      return;
-    const eagerValues = eagerValuesRef.current;
-    assert(eagerValues, "Eager values not found");
-    const {
-      panelDataArray: panelDataArray2
-    } = eagerValues, groupElement = getPanelGroupElement(groupId, panelGroupElement);
-    assert(groupElement != null, `No group found for id "${groupId}"`);
-    const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement);
-    assert(handles, `No resize handles found for group id "${groupId}"`);
-    const cleanupFunctions = handles.map((handle) => {
-      const handleId = handle.getAttribute("data-panel-resize-handle-id");
-      assert(handleId, "Resize handle element has no handle id attribute");
-      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelDataArray2, panelGroupElement);
-      if (idBefore == null || idAfter == null)
-        return () => {
-        };
-      const onKeyDown = (event) => {
-        if (!event.defaultPrevented)
-          switch (event.key) {
-            case "Enter": {
-              event.preventDefault();
-              const index = panelDataArray2.findIndex((panelData) => panelData.id === idBefore);
-              if (index >= 0) {
-                const panelData = panelDataArray2[index];
-                assert(panelData, `No panel data found for index ${index}`);
-                const size = layout[index], {
-                  collapsedSize = 0,
-                  collapsible,
-                  minSize = 0
-                } = panelData.constraints;
-                if (size != null && collapsible) {
-                  const nextLayout = adjustLayoutByDelta({
-                    delta: fuzzyNumbersEqual(size, collapsedSize) ? minSize - collapsedSize : collapsedSize - size,
-                    initialLayout: layout,
-                    panelConstraints: panelDataArray2.map((panelData2) => panelData2.constraints),
-                    pivotIndices: determinePivotIndices(groupId, handleId, panelGroupElement),
-                    prevLayout: layout,
-                    trigger: "keyboard"
-                  });
-                  layout !== nextLayout && setLayout(nextLayout);
-                }
-              }
-              break;
-            }
-          }
-      };
-      return handle.addEventListener("keydown", onKeyDown), () => {
-        handle.removeEventListener("keydown", onKeyDown);
-      };
-    });
-    return () => {
-      cleanupFunctions.forEach((cleanupFunction) => cleanupFunction());
-    };
-  }, [panelGroupElement, committedValuesRef, eagerValuesRef, groupId, layout, panelDataArray, setLayout]);
-}
-function areEqual(arrayA, arrayB) {
-  if (arrayA.length !== arrayB.length)
-    return !1;
-  for (let index = 0; index < arrayA.length; index++)
-    if (arrayA[index] !== arrayB[index])
-      return !1;
-  return !0;
-}
-function getResizeEventCursorPosition(direction, event) {
-  const isHorizontal = direction === "horizontal", {
-    x,
-    y
-  } = getResizeEventCoordinates(event);
-  return isHorizontal ? x : y;
-}
-function calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement) {
-  const isHorizontal = direction === "horizontal", handleElement = getResizeHandleElement(dragHandleId, panelGroupElement);
-  assert(handleElement, `No resize handle element found for id "${dragHandleId}"`);
-  const groupId = handleElement.getAttribute("data-panel-group-id");
-  assert(groupId, "Resize handle element has no group id attribute");
-  let {
-    initialCursorPosition
-  } = initialDragState;
-  const cursorPosition = getResizeEventCursorPosition(direction, event), groupElement = getPanelGroupElement(groupId, panelGroupElement);
-  assert(groupElement, `No group element found for id "${groupId}"`);
-  const groupRect = groupElement.getBoundingClientRect(), groupSizeInPixels = isHorizontal ? groupRect.width : groupRect.height;
-  return (cursorPosition - initialCursorPosition) / groupSizeInPixels * 100;
-}
-function calculateDeltaPercentage(event, dragHandleId, direction, initialDragState, keyboardResizeBy, panelGroupElement) {
-  if (isKeyDown(event)) {
-    const isHorizontal = direction === "horizontal";
-    let delta = 0;
-    event.shiftKey ? delta = 100 : keyboardResizeBy != null ? delta = keyboardResizeBy : delta = 10;
-    let movement = 0;
-    switch (event.key) {
-      case "ArrowDown":
-        movement = isHorizontal ? 0 : delta;
-        break;
-      case "ArrowLeft":
-        movement = isHorizontal ? -delta : 0;
-        break;
-      case "ArrowRight":
-        movement = isHorizontal ? delta : 0;
-        break;
-      case "ArrowUp":
-        movement = isHorizontal ? 0 : -delta;
-        break;
-      case "End":
-        movement = 100;
-        break;
-      case "Home":
-        movement = -100;
-        break;
-    }
-    return movement;
-  } else
-    return initialDragState == null ? 0 : calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement);
-}
-function calculateUnsafeDefaultLayout({
-  panelDataArray
-}) {
-  const layout = Array(panelDataArray.length), panelConstraintsArray = panelDataArray.map((panelData) => panelData.constraints);
-  let numPanelsWithSizes = 0, remainingSize = 100;
-  for (let index = 0; index < panelDataArray.length; index++) {
-    const panelConstraints = panelConstraintsArray[index];
-    assert(panelConstraints, `Panel constraints not found for index ${index}`);
-    const {
-      defaultSize
-    } = panelConstraints;
-    defaultSize != null && (numPanelsWithSizes++, layout[index] = defaultSize, remainingSize -= defaultSize);
-  }
-  for (let index = 0; index < panelDataArray.length; index++) {
-    const panelConstraints = panelConstraintsArray[index];
-    assert(panelConstraints, `Panel constraints not found for index ${index}`);
-    const {
-      defaultSize
-    } = panelConstraints;
-    if (defaultSize != null)
-      continue;
-    const numRemainingPanels = panelDataArray.length - numPanelsWithSizes, size = remainingSize / numRemainingPanels;
-    numPanelsWithSizes++, layout[index] = size, remainingSize -= size;
-  }
-  return layout;
-}
-function callPanelCallbacks(panelsArray, layout, panelIdToLastNotifiedSizeMap) {
-  layout.forEach((size, index) => {
-    const panelData = panelsArray[index];
-    assert(panelData, `Panel data not found for index ${index}`);
-    const {
-      callbacks,
-      constraints,
-      id: panelId
-    } = panelData, {
-      collapsedSize = 0,
-      collapsible
-    } = constraints, lastNotifiedSize = panelIdToLastNotifiedSizeMap[panelId];
-    if (lastNotifiedSize == null || size !== lastNotifiedSize) {
-      panelIdToLastNotifiedSizeMap[panelId] = size;
-      const {
-        onCollapse,
-        onExpand,
-        onResize
-      } = callbacks;
-      onResize && onResize(size, lastNotifiedSize), collapsible && (onCollapse || onExpand) && (onExpand && (lastNotifiedSize == null || fuzzyNumbersEqual$1(
-      lastNotifiedSize, collapsedSize)) && !fuzzyNumbersEqual$1(size, collapsedSize) && onExpand(), onCollapse && (lastNotifiedSize == null || !fuzzyNumbersEqual$1(
-      lastNotifiedSize, collapsedSize)) && fuzzyNumbersEqual$1(size, collapsedSize) && onCollapse());
-    }
-  });
-}
-function compareLayouts(a, b) {
-  if (a.length !== b.length)
-    return !1;
-  for (let index = 0; index < a.length; index++)
-    if (a[index] != b[index])
-      return !1;
-  return !0;
-}
-function computePanelFlexBoxStyle({
-  defaultSize,
-  dragState,
-  layout,
-  panelData,
-  panelIndex,
-  precision = 3
-}) {
-  const size = layout[panelIndex];
-  let flexGrow;
-  return size == null ? flexGrow = defaultSize != null ? defaultSize.toPrecision(precision) : "1" : panelData.length === 1 ? flexGrow = "1" : flexGrow =
-  size.toPrecision(precision), {
-    flexBasis: 0,
-    flexGrow,
-    flexShrink: 1,
-    // Without this, Panel sizes may be unintentionally overridden by their content
-    overflow: "hidden",
-    // Disable pointer events inside of a panel during resize
-    // This avoid edge cases like nested iframes
-    pointerEvents: dragState !== null ? "none" : void 0
-  };
-}
-function debounce(callback, durationMs = 10) {
-  let timeoutId = null;
-  return (...args) => {
-    timeoutId !== null && clearTimeout(timeoutId), timeoutId = setTimeout(() => {
-      callback(...args);
-    }, durationMs);
-  };
-}
-function initializeDefaultStorage(storageObject) {
-  try {
-    if (typeof localStorage < "u")
-      storageObject.getItem = (name) => localStorage.getItem(name), storageObject.setItem = (name, value) => {
-        localStorage.setItem(name, value);
-      };
-    else
-      throw new Error("localStorage not supported in this environment");
-  } catch (error) {
-    console.error(error), storageObject.getItem = () => null, storageObject.setItem = () => {
-    };
-  }
-}
-function getPanelGroupKey(autoSaveId) {
-  return `react-resizable-panels:${autoSaveId}`;
-}
-function getPanelKey(panels) {
-  return panels.map((panel) => {
-    const {
-      constraints,
-      id,
-      idIsFromProps,
-      order
-    } = panel;
-    return idIsFromProps ? id : order ? `${order}:${JSON.stringify(constraints)}` : JSON.stringify(constraints);
-  }).sort((a, b) => a.localeCompare(b)).join(",");
-}
-function loadSerializedPanelGroupState(autoSaveId, storage) {
-  try {
-    const panelGroupKey = getPanelGroupKey(autoSaveId), serialized = storage.getItem(panelGroupKey);
-    if (serialized) {
-      const parsed = JSON.parse(serialized);
-      if (typeof parsed == "object" && parsed != null)
-        return parsed;
-    }
-  } catch {
-  }
-  return null;
-}
-function loadPanelGroupState(autoSaveId, panels, storage) {
-  var _loadSerializedPanelG, _state$panelKey;
-  const state = (_loadSerializedPanelG = loadSerializedPanelGroupState(autoSaveId, storage)) !== null && _loadSerializedPanelG !== void 0 ? _loadSerializedPanelG :
-  {}, panelKey = getPanelKey(panels);
-  return (_state$panelKey = state[panelKey]) !== null && _state$panelKey !== void 0 ? _state$panelKey : null;
-}
-function savePanelGroupState(autoSaveId, panels, panelSizesBeforeCollapse, sizes, storage) {
-  var _loadSerializedPanelG2;
-  const panelGroupKey = getPanelGroupKey(autoSaveId), panelKey = getPanelKey(panels), state = (_loadSerializedPanelG2 = loadSerializedPanelGroupState(
-  autoSaveId, storage)) !== null && _loadSerializedPanelG2 !== void 0 ? _loadSerializedPanelG2 : {};
-  state[panelKey] = {
-    expandToSizes: Object.fromEntries(panelSizesBeforeCollapse.entries()),
-    layout: sizes
-  };
-  try {
-    storage.setItem(panelGroupKey, JSON.stringify(state));
-  } catch (error) {
-    console.error(error);
-  }
-}
-function validatePanelGroupLayout({
-  layout: prevLayout,
-  panelConstraints
-}) {
-  const nextLayout = [...prevLayout], nextLayoutTotalSize = nextLayout.reduce((accumulated, current) => accumulated + current, 0);
-  if (nextLayout.length !== panelConstraints.length)
-    throw Error(`Invalid ${panelConstraints.length} panel layout: ${nextLayout.map((size) => `${size}%`).join(", ")}`);
-  if (!fuzzyNumbersEqual(nextLayoutTotalSize, 100))
-    for (let index = 0; index < panelConstraints.length; index++) {
-      const unsafeSize = nextLayout[index];
-      assert(unsafeSize != null, `No layout data found for index ${index}`);
-      const safeSize = 100 / nextLayoutTotalSize * unsafeSize;
-      nextLayout[index] = safeSize;
-    }
-  let remainingSize = 0;
-  for (let index = 0; index < panelConstraints.length; index++) {
-    const unsafeSize = nextLayout[index];
-    assert(unsafeSize != null, `No layout data found for index ${index}`);
-    const safeSize = resizePanel({
-      panelConstraints,
-      panelIndex: index,
-      size: unsafeSize
-    });
-    unsafeSize != safeSize && (remainingSize += unsafeSize - safeSize, nextLayout[index] = safeSize);
-  }
-  if (!fuzzyNumbersEqual(remainingSize, 0))
-    for (let index = 0; index < panelConstraints.length; index++) {
-      const prevSize = nextLayout[index];
-      assert(prevSize != null, `No layout data found for index ${index}`);
-      const unsafeSize = prevSize + remainingSize, safeSize = resizePanel({
-        panelConstraints,
-        panelIndex: index,
-        size: unsafeSize
-      });
-      if (prevSize !== safeSize && (remainingSize -= safeSize - prevSize, nextLayout[index] = safeSize, fuzzyNumbersEqual(remainingSize, 0)))
-        break;
-    }
-  return nextLayout;
-}
-const LOCAL_STORAGE_DEBOUNCE_INTERVAL = 100, defaultStorage = {
-  getItem: (name) => (initializeDefaultStorage(defaultStorage), defaultStorage.getItem(name)),
-  setItem: (name, value) => {
-    initializeDefaultStorage(defaultStorage), defaultStorage.setItem(name, value);
-  }
-}, debounceMap = {};
-function PanelGroupWithForwardedRef({
-  autoSaveId = null,
-  children,
-  className: classNameFromProps = "",
-  direction,
-  forwardedRef,
-  id: idFromProps = null,
-  onLayout = null,
-  keyboardResizeBy = null,
-  storage = defaultStorage,
-  style: styleFromProps,
-  tagName: Type = "div",
-  ...rest
-}) {
-  const groupId = useUniqueId(idFromProps), panelGroupElementRef = useRef(null), [dragState, setDragState] = useState(null), [layout, setLayout] = useState(
-  []), forceUpdate = useForceUpdate(), panelIdToLastNotifiedSizeMapRef = useRef({}), panelSizeBeforeCollapseRef = useRef(/* @__PURE__ */ new Map()), prevDeltaRef = useRef(
-  0), committedValuesRef = useRef({
-    autoSaveId,
-    direction,
-    dragState,
-    id: groupId,
-    keyboardResizeBy,
-    onLayout,
-    storage
-  }), eagerValuesRef = useRef({
-    layout,
-    panelDataArray: [],
-    panelDataArrayChanged: !1
-  });
-  useRef({
-    didLogIdAndOrderWarning: !1,
-    didLogPanelConstraintsWarning: !1,
-    prevPanelIds: []
-  }), useImperativeHandle(forwardedRef, () => ({
-    getId: () => committedValuesRef.current.id,
-    getLayout: () => {
-      const {
-        layout: layout2
-      } = eagerValuesRef.current;
-      return layout2;
-    },
-    setLayout: (unsafeLayout) => {
-      const {
-        onLayout: onLayout2
-      } = committedValuesRef.current, {
-        layout: prevLayout,
-        panelDataArray
-      } = eagerValuesRef.current, safeLayout = validatePanelGroupLayout({
-        layout: unsafeLayout,
-        panelConstraints: panelDataArray.map((panelData) => panelData.constraints)
-      });
-      areEqual(prevLayout, safeLayout) || (setLayout(safeLayout), eagerValuesRef.current.layout = safeLayout, onLayout2 && onLayout2(safeLayout), callPanelCallbacks(
-      panelDataArray, safeLayout, panelIdToLastNotifiedSizeMapRef.current));
-    }
-  }), []), useIsomorphicLayoutEffect(() => {
-    committedValuesRef.current.autoSaveId = autoSaveId, committedValuesRef.current.direction = direction, committedValuesRef.current.dragState = dragState,
-    committedValuesRef.current.id = groupId, committedValuesRef.current.onLayout = onLayout, committedValuesRef.current.storage = storage;
-  }), useWindowSplitterPanelGroupBehavior({
-    committedValuesRef,
-    eagerValuesRef,
-    groupId,
-    layout,
-    panelDataArray: eagerValuesRef.current.panelDataArray,
-    setLayout,
-    panelGroupElement: panelGroupElementRef.current
-  }), useEffect(() => {
-    const {
-      panelDataArray
-    } = eagerValuesRef.current;
-    if (autoSaveId) {
-      if (layout.length === 0 || layout.length !== panelDataArray.length)
-        return;
-      let debouncedSave = debounceMap[autoSaveId];
-      debouncedSave == null && (debouncedSave = debounce(savePanelGroupState, LOCAL_STORAGE_DEBOUNCE_INTERVAL), debounceMap[autoSaveId] = debouncedSave);
-      const clonedPanelDataArray = [...panelDataArray], clonedPanelSizesBeforeCollapse = new Map(panelSizeBeforeCollapseRef.current);
-      debouncedSave(autoSaveId, clonedPanelDataArray, clonedPanelSizesBeforeCollapse, layout, storage);
-    }
-  }, [autoSaveId, layout, storage]), useEffect(() => {
-  });
-  const collapsePanel = useCallback((panelData) => {
-    const {
-      onLayout: onLayout2
-    } = committedValuesRef.current, {
-      layout: prevLayout,
-      panelDataArray
-    } = eagerValuesRef.current;
-    if (panelData.constraints.collapsible) {
-      const panelConstraintsArray = panelDataArray.map((panelData2) => panelData2.constraints), {
-        collapsedSize = 0,
-        panelSize,
-        pivotIndices
-      } = panelDataHelper(panelDataArray, panelData, prevLayout);
-      if (assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`), !fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
-        panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);
-        const delta = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1 ? panelSize - collapsedSize : collapsedSize - panelSize,
-        nextLayout = adjustLayoutByDelta({
-          delta,
-          initialLayout: prevLayout,
-          panelConstraints: panelConstraintsArray,
-          pivotIndices,
-          prevLayout,
-          trigger: "imperative-api"
-        });
-        compareLayouts(prevLayout, nextLayout) || (setLayout(nextLayout), eagerValuesRef.current.layout = nextLayout, onLayout2 && onLayout2(nextLayout),
-        callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current));
-      }
-    }
-  }, []), expandPanel = useCallback((panelData, minSizeOverride) => {
-    const {
-      onLayout: onLayout2
-    } = committedValuesRef.current, {
-      layout: prevLayout,
-      panelDataArray
-    } = eagerValuesRef.current;
-    if (panelData.constraints.collapsible) {
-      const panelConstraintsArray = panelDataArray.map((panelData2) => panelData2.constraints), {
-        collapsedSize = 0,
-        panelSize = 0,
-        minSize: minSizeFromProps = 0,
-        pivotIndices
-      } = panelDataHelper(panelDataArray, panelData, prevLayout), minSize = minSizeOverride ?? minSizeFromProps;
-      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {
-        const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id), baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize :
-        minSize, delta = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1 ? panelSize - baseSize : baseSize - panelSize, nextLayout = adjustLayoutByDelta(
-        {
-          delta,
-          initialLayout: prevLayout,
-          panelConstraints: panelConstraintsArray,
-          pivotIndices,
-          prevLayout,
-          trigger: "imperative-api"
-        });
-        compareLayouts(prevLayout, nextLayout) || (setLayout(nextLayout), eagerValuesRef.current.layout = nextLayout, onLayout2 && onLayout2(nextLayout),
-        callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current));
-      }
-    }
-  }, []), getPanelSize = useCallback((panelData) => {
-    const {
-      layout: layout2,
-      panelDataArray
-    } = eagerValuesRef.current, {
-      panelSize
-    } = panelDataHelper(panelDataArray, panelData, layout2);
-    return assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`), panelSize;
-  }, []), getPanelStyle = useCallback((panelData, defaultSize) => {
-    const {
-      panelDataArray
-    } = eagerValuesRef.current, panelIndex = findPanelDataIndex(panelDataArray, panelData);
-    return computePanelFlexBoxStyle({
-      defaultSize,
-      dragState,
-      layout,
-      panelData: panelDataArray,
-      panelIndex
-    });
-  }, [dragState, layout]), isPanelCollapsed = useCallback((panelData) => {
-    const {
-      layout: layout2,
-      panelDataArray
-    } = eagerValuesRef.current, {
-      collapsedSize = 0,
-      collapsible,
-      panelSize
-    } = panelDataHelper(panelDataArray, panelData, layout2);
-    return assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`), collapsible === !0 && fuzzyNumbersEqual$1(panelSize, collapsedSize);
-  }, []), isPanelExpanded = useCallback((panelData) => {
-    const {
-      layout: layout2,
-      panelDataArray
-    } = eagerValuesRef.current, {
-      collapsedSize = 0,
-      collapsible,
-      panelSize
-    } = panelDataHelper(panelDataArray, panelData, layout2);
-    return assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`), !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) >
-    0;
-  }, []), registerPanel = useCallback((panelData) => {
-    const {
-      panelDataArray
-    } = eagerValuesRef.current;
-    panelDataArray.push(panelData), panelDataArray.sort((panelA, panelB) => {
-      const orderA = panelA.order, orderB = panelB.order;
-      return orderA == null && orderB == null ? 0 : orderA == null ? -1 : orderB == null ? 1 : orderA - orderB;
-    }), eagerValuesRef.current.panelDataArrayChanged = !0, forceUpdate();
-  }, [forceUpdate]);
-  useIsomorphicLayoutEffect(() => {
-    if (eagerValuesRef.current.panelDataArrayChanged) {
-      eagerValuesRef.current.panelDataArrayChanged = !1;
-      const {
-        autoSaveId: autoSaveId2,
-        onLayout: onLayout2,
-        storage: storage2
-      } = committedValuesRef.current, {
-        layout: prevLayout,
-        panelDataArray
-      } = eagerValuesRef.current;
-      let unsafeLayout = null;
-      if (autoSaveId2) {
-        const state = loadPanelGroupState(autoSaveId2, panelDataArray, storage2);
-        state && (panelSizeBeforeCollapseRef.current = new Map(Object.entries(state.expandToSizes)), unsafeLayout = state.layout);
-      }
-      unsafeLayout == null && (unsafeLayout = calculateUnsafeDefaultLayout({
-        panelDataArray
-      }));
-      const nextLayout = validatePanelGroupLayout({
-        layout: unsafeLayout,
-        panelConstraints: panelDataArray.map((panelData) => panelData.constraints)
-      });
-      areEqual(prevLayout, nextLayout) || (setLayout(nextLayout), eagerValuesRef.current.layout = nextLayout, onLayout2 && onLayout2(nextLayout), callPanelCallbacks(
-      panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current));
-    }
-  }), useIsomorphicLayoutEffect(() => {
-    const eagerValues = eagerValuesRef.current;
-    return () => {
-      eagerValues.layout = [];
-    };
-  }, []);
-  const registerResizeHandle2 = useCallback((dragHandleId) => function(event) {
-    event.preventDefault();
-    const panelGroupElement = panelGroupElementRef.current;
-    if (!panelGroupElement)
-      return () => null;
-    const {
-      direction: direction2,
-      dragState: dragState2,
-      id: groupId2,
-      keyboardResizeBy: keyboardResizeBy2,
-      onLayout: onLayout2
-    } = committedValuesRef.current, {
-      layout: prevLayout,
-      panelDataArray
-    } = eagerValuesRef.current, {
-      initialLayout
-    } = dragState2 ?? {}, pivotIndices = determinePivotIndices(groupId2, dragHandleId, panelGroupElement);
-    let delta = calculateDeltaPercentage(event, dragHandleId, direction2, dragState2, keyboardResizeBy2, panelGroupElement);
-    const isHorizontal = direction2 === "horizontal";
-    document.dir === "rtl" && isHorizontal && (delta = -delta);
-    const panelConstraints = panelDataArray.map((panelData) => panelData.constraints), nextLayout = adjustLayoutByDelta({
-      delta,
-      initialLayout: initialLayout ?? prevLayout,
-      panelConstraints,
-      pivotIndices,
-      prevLayout,
-      trigger: isKeyDown(event) ? "keyboard" : "mouse-or-touch"
-    }), layoutChanged = !compareLayouts(prevLayout, nextLayout);
-    (isPointerEvent(event) || isMouseEvent(event)) && prevDeltaRef.current != delta && (prevDeltaRef.current = delta, layoutChanged ? reportConstraintsViolation(
-    dragHandleId, 0) : isHorizontal ? reportConstraintsViolation(dragHandleId, delta < 0 ? EXCEEDED_HORIZONTAL_MIN : EXCEEDED_HORIZONTAL_MAX) : reportConstraintsViolation(
-    dragHandleId, delta < 0 ? EXCEEDED_VERTICAL_MIN : EXCEEDED_VERTICAL_MAX)), layoutChanged && (setLayout(nextLayout), eagerValuesRef.current.layout =
-    nextLayout, onLayout2 && onLayout2(nextLayout), callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current));
-  }, []), resizePanel2 = useCallback((panelData, unsafePanelSize) => {
-    const {
-      onLayout: onLayout2
-    } = committedValuesRef.current, {
-      layout: prevLayout,
-      panelDataArray
-    } = eagerValuesRef.current, panelConstraintsArray = panelDataArray.map((panelData2) => panelData2.constraints), {
-      panelSize,
-      pivotIndices
-    } = panelDataHelper(panelDataArray, panelData, prevLayout);
-    assert(panelSize != null, `Panel size not found for panel "${panelData.id}"`);
-    const delta = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1 ? panelSize - unsafePanelSize : unsafePanelSize - panelSize,
-    nextLayout = adjustLayoutByDelta({
-      delta,
-      initialLayout: prevLayout,
-      panelConstraints: panelConstraintsArray,
-      pivotIndices,
-      prevLayout,
-      trigger: "imperative-api"
-    });
-    compareLayouts(prevLayout, nextLayout) || (setLayout(nextLayout), eagerValuesRef.current.layout = nextLayout, onLayout2 && onLayout2(nextLayout), callPanelCallbacks(
-    panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current));
-  }, []), reevaluatePanelConstraints = useCallback((panelData, prevConstraints) => {
-    const {
-      layout: layout2,
-      panelDataArray
-    } = eagerValuesRef.current, {
-      collapsedSize: prevCollapsedSize = 0,
-      collapsible: prevCollapsible
-    } = prevConstraints, {
-      collapsedSize: nextCollapsedSize = 0,
-      collapsible: nextCollapsible,
-      maxSize: nextMaxSize = 100,
-      minSize: nextMinSize = 0
-    } = panelData.constraints, {
-      panelSize: prevPanelSize
-    } = panelDataHelper(panelDataArray, panelData, layout2);
-    prevPanelSize != null && (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize) ? fuzzyNumbersEqual$1(prevCollapsedSize,
-    nextCollapsedSize) || resizePanel2(panelData, nextCollapsedSize) : prevPanelSize < nextMinSize ? resizePanel2(panelData, nextMinSize) : prevPanelSize >
-    nextMaxSize && resizePanel2(panelData, nextMaxSize));
-  }, [resizePanel2]), startDragging = useCallback((dragHandleId, event) => {
-    const {
-      direction: direction2
-    } = committedValuesRef.current, {
-      layout: layout2
-    } = eagerValuesRef.current;
-    if (!panelGroupElementRef.current)
-      return;
-    const handleElement = getResizeHandleElement(dragHandleId, panelGroupElementRef.current);
-    assert(handleElement, `Drag handle element not found for id "${dragHandleId}"`);
-    const initialCursorPosition = getResizeEventCursorPosition(direction2, event);
-    setDragState({
-      dragHandleId,
-      dragHandleRect: handleElement.getBoundingClientRect(),
-      initialCursorPosition,
-      initialLayout: layout2
-    });
-  }, []), stopDragging = useCallback(() => {
-    setDragState(null);
-  }, []), unregisterPanel = useCallback((panelData) => {
-    const {
-      panelDataArray
-    } = eagerValuesRef.current, index = findPanelDataIndex(panelDataArray, panelData);
-    index >= 0 && (panelDataArray.splice(index, 1), delete panelIdToLastNotifiedSizeMapRef.current[panelData.id], eagerValuesRef.current.panelDataArrayChanged =
-    !0, forceUpdate());
-  }, [forceUpdate]), context = useMemo(() => ({
-    collapsePanel,
-    direction,
-    dragState,
-    expandPanel,
-    getPanelSize,
-    getPanelStyle,
-    groupId,
-    isPanelCollapsed,
-    isPanelExpanded,
-    reevaluatePanelConstraints,
-    registerPanel,
-    registerResizeHandle: registerResizeHandle2,
-    resizePanel: resizePanel2,
-    startDragging,
-    stopDragging,
-    unregisterPanel,
-    panelGroupElement: panelGroupElementRef.current
-  }), [collapsePanel, dragState, direction, expandPanel, getPanelSize, getPanelStyle, groupId, isPanelCollapsed, isPanelExpanded, reevaluatePanelConstraints,
-  registerPanel, registerResizeHandle2, resizePanel2, startDragging, stopDragging, unregisterPanel]), style = {
-    display: "flex",
-    flexDirection: direction === "horizontal" ? "row" : "column",
-    height: "100%",
-    overflow: "hidden",
-    width: "100%"
-  };
-  return createElement(PanelGroupContext.Provider, {
-    value: context
-  }, createElement(Type, {
-    ...rest,
-    children,
-    className: classNameFromProps,
-    id: idFromProps,
-    ref: panelGroupElementRef,
-    style: {
-      ...style,
-      ...styleFromProps
-    },
-    // CSS selectors
-    "data-panel-group": "",
-    "data-panel-group-direction": direction,
-    "data-panel-group-id": groupId
-  }));
-}
-const PanelGroup = forwardRef((props2, ref) => createElement(PanelGroupWithForwardedRef, {
-  ...props2,
-  forwardedRef: ref
-}));
-PanelGroupWithForwardedRef.displayName = "PanelGroup";
-PanelGroup.displayName = "forwardRef(PanelGroup)";
-function findPanelDataIndex(panelDataArray, panelData) {
-  return panelDataArray.findIndex((prevPanelData) => prevPanelData === panelData || prevPanelData.id === panelData.id);
-}
-function panelDataHelper(panelDataArray, panelData, layout) {
-  const panelIndex = findPanelDataIndex(panelDataArray, panelData), pivotIndices = panelIndex === panelDataArray.length - 1 ? [panelIndex - 1, panelIndex] :
-  [panelIndex, panelIndex + 1], panelSize = layout[panelIndex];
-  return {
-    ...panelData.constraints,
-    panelSize,
-    pivotIndices
-  };
-}
-function useWindowSplitterResizeHandlerBehavior({
-  disabled,
-  handleId,
-  resizeHandler,
-  panelGroupElement
-}) {
-  useEffect(() => {
-    if (disabled || resizeHandler == null || panelGroupElement == null)
-      return;
-    const handleElement = getResizeHandleElement(handleId, panelGroupElement);
-    if (handleElement == null)
-      return;
-    const onKeyDown = (event) => {
-      if (!event.defaultPrevented)
-        switch (event.key) {
-          case "ArrowDown":
-          case "ArrowLeft":
-          case "ArrowRight":
-          case "ArrowUp":
-          case "End":
-          case "Home": {
-            event.preventDefault(), resizeHandler(event);
-            break;
-          }
-          case "F6": {
-            event.preventDefault();
-            const groupId = handleElement.getAttribute("data-panel-group-id");
-            assert(groupId, `No group element found for id "${groupId}"`);
-            const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement), index = getResizeHandleElementIndex(groupId, handleId, panelGroupElement);
-            assert(index !== null, `No resize element found for id "${handleId}"`);
-            const nextIndex = event.shiftKey ? index > 0 ? index - 1 : handles.length - 1 : index + 1 < handles.length ? index + 1 : 0;
-            handles[nextIndex].focus();
-            break;
-          }
-        }
-    };
-    return handleElement.addEventListener("keydown", onKeyDown), () => {
-      handleElement.removeEventListener("keydown", onKeyDown);
-    };
-  }, [panelGroupElement, disabled, handleId, resizeHandler]);
-}
-function PanelResizeHandle({
-  children = null,
-  className: classNameFromProps = "",
-  disabled = !1,
-  hitAreaMargins,
-  id: idFromProps,
-  onBlur,
-  onDragging,
-  onFocus,
-  style: styleFromProps = {},
-  tabIndex = 0,
-  tagName: Type = "div",
-  ...rest
-}) {
-  var _hitAreaMargins$coars, _hitAreaMargins$fine;
-  const elementRef = useRef(null), callbacksRef = useRef({
-    onDragging
-  });
-  useEffect(() => {
-    callbacksRef.current.onDragging = onDragging;
-  });
-  const panelGroupContext = useContext(PanelGroupContext);
-  if (panelGroupContext === null)
-    throw Error("PanelResizeHandle components must be rendered within a PanelGroup container");
-  const {
-    direction,
-    groupId,
-    registerResizeHandle: registerResizeHandleWithParentGroup,
-    startDragging,
-    stopDragging,
-    panelGroupElement
-  } = panelGroupContext, resizeHandleId = useUniqueId(idFromProps), [state, setState] = useState("inactive"), [isFocused, setIsFocused] = useState(!1),
-  [resizeHandler, setResizeHandler] = useState(null), committedValuesRef = useRef({
-    state
-  });
-  useIsomorphicLayoutEffect(() => {
-    committedValuesRef.current.state = state;
-  }), useEffect(() => {
-    if (disabled)
-      setResizeHandler(null);
-    else {
-      const resizeHandler2 = registerResizeHandleWithParentGroup(resizeHandleId);
-      setResizeHandler(() => resizeHandler2);
-    }
-  }, [disabled, resizeHandleId, registerResizeHandleWithParentGroup]);
-  const coarseHitAreaMargins = (_hitAreaMargins$coars = hitAreaMargins?.coarse) !== null && _hitAreaMargins$coars !== void 0 ? _hitAreaMargins$coars :
-  15, fineHitAreaMargins = (_hitAreaMargins$fine = hitAreaMargins?.fine) !== null && _hitAreaMargins$fine !== void 0 ? _hitAreaMargins$fine : 5;
-  return useEffect(() => {
-    if (disabled || resizeHandler == null)
-      return;
-    const element = elementRef.current;
-    return assert(element, "Element ref not attached"), registerResizeHandle(resizeHandleId, element, direction, {
-      coarse: coarseHitAreaMargins,
-      fine: fineHitAreaMargins
-    }, (action, isActive, event) => {
-      if (isActive)
-        switch (action) {
-          case "down": {
-            setState("drag"), startDragging(resizeHandleId, event);
-            const {
-              onDragging: onDragging2
-            } = callbacksRef.current;
-            onDragging2 && onDragging2(!0);
-            break;
-          }
-          case "move": {
-            const {
-              state: state2
-            } = committedValuesRef.current;
-            state2 !== "drag" && setState("hover"), resizeHandler(event);
-            break;
-          }
-          case "up": {
-            setState("hover"), stopDragging();
-            const {
-              onDragging: onDragging2
-            } = callbacksRef.current;
-            onDragging2 && onDragging2(!1);
-            break;
-          }
-        }
-      else
-        setState("inactive");
-    });
-  }, [coarseHitAreaMargins, direction, disabled, fineHitAreaMargins, registerResizeHandleWithParentGroup, resizeHandleId, resizeHandler, startDragging,
-  stopDragging]), useWindowSplitterResizeHandlerBehavior({
-    disabled,
-    handleId: resizeHandleId,
-    resizeHandler,
-    panelGroupElement
-  }), createElement(Type, {
-    ...rest,
-    children,
-    className: classNameFromProps,
-    id: idFromProps,
-    onBlur: () => {
-      setIsFocused(!1), onBlur?.();
-    },
-    onFocus: () => {
-      setIsFocused(!0), onFocus?.();
-    },
-    ref: elementRef,
-    role: "separator",
-    style: {
-      ...{
-        touchAction: "none",
-        userSelect: "none"
-      },
-      ...styleFromProps
-    },
-    tabIndex,
-    // CSS selectors
-    "data-panel-group-direction": direction,
-    "data-panel-group-id": groupId,
-    "data-resize-handle": "",
-    "data-resize-handle-active": state === "drag" ? "pointer" : isFocused ? "keyboard" : void 0,
-    "data-resize-handle-state": state,
-    "data-panel-resize-handle-enabled": !disabled,
-    "data-panel-resize-handle-id": resizeHandleId
-  });
-}
-PanelResizeHandle.displayName = "PanelResizeHandle";
-export {
-  PanelGroup as P,
-  Panel as a,
-  PanelResizeHandle as b
-};