react-resizable-panels 0.0.53 → 0.0.55

package/dist/react-resizable-panels.browser.esm.js

@@ -0,0 +1,1682 @@
+import * as React from 'react';
+
+// This module exists to work around Webpack issue https://github.com/webpack/webpack/issues/14814
+
+// eslint-disable-next-line no-restricted-imports
+
+const {
+  createElement,
+  createContext,
+  forwardRef,
+  useCallback,
+  useContext,
+  useEffect,
+  useImperativeHandle,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} = React;
+
+// `toString()` prevents bundlers from trying to `import { useId } from 'react'`
+const useId = React["useId".toString()];
+
+const useIsomorphicLayoutEffect = useLayoutEffect ;
+
+const wrappedUseId = typeof useId === "function" ? useId : () => null;
+let counter = 0;
+function useUniqueId(idFromParams = null) {
+  const idFromUseId = wrappedUseId();
+  const idRef = useRef(idFromParams || idFromUseId || null);
+  if (idRef.current === null) {
+    idRef.current = "" + counter++;
+  }
+  return idRef.current;
+}
+
+const PanelGroupContext = createContext(null);
+PanelGroupContext.displayName = "PanelGroupContext";
+
+function PanelWithForwardedRef({
+  children = null,
+  className: classNameFromProps = "",
+  collapsedSize = 0,
+  collapsible = false,
+  defaultSize = null,
+  forwardedRef,
+  id: idFromProps = null,
+  maxSize = null,
+  minSize,
+  onCollapse = null,
+  onResize = null,
+  order = null,
+  style: styleFromProps = {},
+  tagName: Type = "div"
+}) {
+  const context = useContext(PanelGroupContext);
+  if (context === null) {
+    throw Error(`Panel components must be rendered within a PanelGroup container`);
+  }
+  const panelId = useUniqueId(idFromProps);
+  const {
+    collapsePanel,
+    expandPanel,
+    getPanelSize,
+    getPanelStyle,
+    registerPanel,
+    resizePanel,
+    units,
+    unregisterPanel
+  } = context;
+  if (minSize == null) {
+    if (units === "percentages") {
+      // Mimics legacy default value for percentage based panel groups
+      minSize = 10;
+    } else {
+      // There is no meaningful minimum pixel default we can provide
+      minSize = 0;
+    }
+  }
+
+  // Use a ref to guard against users passing inline props
+  const callbacksRef = useRef({
+    onCollapse,
+    onResize
+  });
+  useEffect(() => {
+    callbacksRef.current.onCollapse = onCollapse;
+    callbacksRef.current.onResize = onResize;
+  });
+  const style = getPanelStyle(panelId, defaultSize);
+  const committedValuesRef = useRef({
+    size: parseSizeFromStyle(style)
+  });
+  const panelDataRef = useRef({
+    callbacksRef,
+    collapsedSize,
+    collapsible,
+    defaultSize,
+    id: panelId,
+    idWasAutoGenerated: idFromProps == null,
+    maxSize,
+    minSize,
+    order
+  });
+  useIsomorphicLayoutEffect(() => {
+    committedValuesRef.current.size = parseSizeFromStyle(style);
+    panelDataRef.current.callbacksRef = callbacksRef;
+    panelDataRef.current.collapsedSize = collapsedSize;
+    panelDataRef.current.collapsible = collapsible;
+    panelDataRef.current.defaultSize = defaultSize;
+    panelDataRef.current.id = panelId;
+    panelDataRef.current.idWasAutoGenerated = idFromProps == null;
+    panelDataRef.current.maxSize = maxSize;
+    panelDataRef.current.minSize = minSize;
+    panelDataRef.current.order = order;
+  });
+  useIsomorphicLayoutEffect(() => {
+    registerPanel(panelId, panelDataRef);
+    return () => {
+      unregisterPanel(panelId);
+    };
+  }, [order, panelId, registerPanel, unregisterPanel]);
+  useImperativeHandle(forwardedRef, () => ({
+    collapse: () => collapsePanel(panelId),
+    expand: () => expandPanel(panelId),
+    getCollapsed() {
+      return committedValuesRef.current.size === 0;
+    },
+    getId() {
+      return panelId;
+    },
+    getSize(units) {
+      return getPanelSize(panelId, units);
+    },
+    resize: (percentage, units) => resizePanel(panelId, percentage, units)
+  }), [collapsePanel, expandPanel, getPanelSize, panelId, resizePanel]);
+  return createElement(Type, {
+    children,
+    className: classNameFromProps,
+    "data-panel": "",
+    "data-panel-collapsible": collapsible || undefined,
+    "data-panel-id": panelId,
+    "data-panel-size": parseFloat("" + style.flexGrow).toFixed(1),
+    id: `data-panel-id-${panelId}`,
+    style: {
+      ...style,
+      ...styleFromProps
+    }
+  });
+}
+const Panel = forwardRef((props, ref) => createElement(PanelWithForwardedRef, {
+  ...props,
+  forwardedRef: ref
+}));
+PanelWithForwardedRef.displayName = "Panel";
+Panel.displayName = "forwardRef(Panel)";
+
+// HACK
+function parseSizeFromStyle(style) {
+  const {
+    flexGrow
+  } = style;
+  if (typeof flexGrow === "string") {
+    return parseFloat(flexGrow);
+  } else {
+    return flexGrow;
+  }
+}
+
+const PRECISION = 10;
+
+function adjustByDelta(event, committedValues, idBefore, idAfter, deltaPixels, prevSizes, panelSizeBeforeCollapse, initialDragState) {
+  const {
+    id: groupId,
+    panels,
+    units
+  } = committedValues;
+  const groupSizePixels = units === "pixels" ? getAvailableGroupSizePixels(groupId) : NaN;
+  const {
+    sizes: initialSizes
+  } = initialDragState || {};
+
+  // If we're resizing by mouse or touch, use the initial sizes as a base.
+  // This has the benefit of causing force-collapsed panels to spring back open if drag is reversed.
+  const baseSizes = initialSizes || prevSizes;
+  const panelsArray = panelsMapToSortedArray(panels);
+  const nextSizes = baseSizes.concat();
+  let deltaApplied = 0;
+
+  // A resizing panel affects the panels before or after it.
+  //
+  // A negative delta means the panel immediately after the resizer should grow/expand by decreasing its offset.
+  // Other panels may also need to shrink/contract (and shift) to make room, depending on the min weights.
+  //
+  // A positive delta means the panel immediately before the resizer should "expand".
+  // This is accomplished by shrinking/contracting (and shifting) one or more of the panels after the resizer.
+
+  // Max-bounds check the panel being expanded first.
+  {
+    const pivotId = deltaPixels < 0 ? idAfter : idBefore;
+    const index = panelsArray.findIndex(panel => panel.current.id === pivotId);
+    const panel = panelsArray[index];
+    const baseSize = baseSizes[index];
+    const nextSize = safeResizePanel(units, groupSizePixels, panel, baseSize, baseSize + Math.abs(deltaPixels), event);
+    if (baseSize === nextSize) {
+      // If there's no room for the pivot panel to grow, we can ignore this drag update.
+      return baseSizes;
+    } else {
+      if (nextSize === 0 && baseSize > 0) {
+        panelSizeBeforeCollapse.set(pivotId, baseSize);
+      }
+      deltaPixels = deltaPixels < 0 ? baseSize - nextSize : nextSize - baseSize;
+    }
+  }
+  let pivotId = deltaPixels < 0 ? idBefore : idAfter;
+  let index = panelsArray.findIndex(panel => panel.current.id === pivotId);
+  while (true) {
+    const panel = panelsArray[index];
+    const baseSize = baseSizes[index];
+    const deltaRemaining = Math.abs(deltaPixels) - Math.abs(deltaApplied);
+    const nextSize = safeResizePanel(units, groupSizePixels, panel, baseSize, baseSize - deltaRemaining, event);
+    if (baseSize !== nextSize) {
+      if (nextSize === 0 && baseSize > 0) {
+        panelSizeBeforeCollapse.set(panel.current.id, baseSize);
+      }
+      deltaApplied += baseSize - nextSize;
+      nextSizes[index] = nextSize;
+      if (deltaApplied.toPrecision(PRECISION).localeCompare(Math.abs(deltaPixels).toPrecision(PRECISION), undefined, {
+        numeric: true
+      }) >= 0) {
+        break;
+      }
+    }
+    if (deltaPixels < 0) {
+      if (--index < 0) {
+        break;
+      }
+    } else {
+      if (++index >= panelsArray.length) {
+        break;
+      }
+    }
+  }
+
+  // If we were unable to resize any of the panels panels, return the previous state.
+  // This will essentially bailout and ignore the "mousemove" event.
+  if (deltaApplied === 0) {
+    return baseSizes;
+  }
+
+  // Adjust the pivot panel before, but only by the amount that surrounding panels were able to shrink/contract.
+  pivotId = deltaPixels < 0 ? idAfter : idBefore;
+  index = panelsArray.findIndex(panel => panel.current.id === pivotId);
+  nextSizes[index] = baseSizes[index] + deltaApplied;
+  return nextSizes;
+}
+function callPanelCallbacks(panelsArray, sizes, panelIdToLastNotifiedSizeMap) {
+  sizes.forEach((size, index) => {
+    const panelRef = panelsArray[index];
+    if (!panelRef) {
+      // Handle initial mount (when panels are registered too late to be in the panels array)
+      // The subsequent render+effects will handle the resize notification
+      return;
+    }
+    const {
+      callbacksRef,
+      collapsedSize,
+      collapsible,
+      id
+    } = panelRef.current;
+    const lastNotifiedSize = panelIdToLastNotifiedSizeMap[id];
+    if (lastNotifiedSize !== size) {
+      panelIdToLastNotifiedSizeMap[id] = size;
+      const {
+        onCollapse,
+        onResize
+      } = callbacksRef.current;
+      if (onResize) {
+        onResize(size, lastNotifiedSize);
+      }
+      if (collapsible && onCollapse) {
+        if ((lastNotifiedSize == null || lastNotifiedSize === collapsedSize) && size !== collapsedSize) {
+          onCollapse(false);
+        } else if (lastNotifiedSize !== collapsedSize && size === collapsedSize) {
+          onCollapse(true);
+        }
+      }
+    }
+  });
+}
+function calculateDefaultLayout({
+  groupId,
+  panels,
+  units
+}) {
+  const groupSizePixels = units === "pixels" ? getAvailableGroupSizePixels(groupId) : NaN;
+  const panelsArray = panelsMapToSortedArray(panels);
+  const sizes = Array(panelsArray.length);
+  let numPanelsWithSizes = 0;
+  let remainingSize = 100;
+
+  // Assigning default sizes requires a couple of passes:
+  // First, all panels with defaultSize should be set as-is
+  for (let index = 0; index < panelsArray.length; index++) {
+    const panel = panelsArray[index];
+    const {
+      defaultSize
+    } = panel.current;
+    if (defaultSize != null) {
+      numPanelsWithSizes++;
+      sizes[index] = units === "pixels" ? defaultSize / groupSizePixels * 100 : defaultSize;
+      remainingSize -= sizes[index];
+    }
+  }
+
+  // Remaining total size should be distributed evenly between panels
+  // This may require two passes, depending on min/max constraints
+  for (let index = 0; index < panelsArray.length; index++) {
+    const panel = panelsArray[index];
+    let {
+      defaultSize,
+      id,
+      maxSize,
+      minSize
+    } = panel.current;
+    if (defaultSize != null) {
+      continue;
+    }
+    if (units === "pixels") {
+      minSize = minSize / groupSizePixels * 100;
+      if (maxSize != null) {
+        maxSize = maxSize / groupSizePixels * 100;
+      }
+    }
+    const remainingPanels = panelsArray.length - numPanelsWithSizes;
+    const size = Math.min(maxSize != null ? maxSize : 100, Math.max(minSize, remainingSize / remainingPanels));
+    sizes[index] = size;
+    numPanelsWithSizes++;
+    remainingSize -= size;
+  }
+
+  // If there is additional, left over space, assign it to any panel(s) that permits it
+  // (It's not worth taking multiple additional passes to evenly distribute)
+  if (remainingSize !== 0) {
+    for (let index = 0; index < panelsArray.length; index++) {
+      const panel = panelsArray[index];
+      let {
+        maxSize,
+        minSize
+      } = panel.current;
+      if (units === "pixels") {
+        minSize = minSize / groupSizePixels * 100;
+        if (maxSize != null) {
+          maxSize = maxSize / groupSizePixels * 100;
+        }
+      }
+      const size = Math.min(maxSize != null ? maxSize : 100, Math.max(minSize, sizes[index] + remainingSize));
+      if (size !== sizes[index]) {
+        remainingSize -= size - sizes[index];
+        sizes[index] = size;
+
+        // Fuzzy comparison to account for imprecise floating point math
+        if (Math.abs(remainingSize).toFixed(3) === "0.000") {
+          break;
+        }
+      }
+    }
+  }
+
+  // Finally, if there is still left-over size, log an error
+  if (Math.abs(remainingSize).toFixed(3) !== "0.000") ;
+  return sizes;
+}
+function getBeforeAndAfterIds(id, panelsArray) {
+  if (panelsArray.length < 2) {
+    return [null, null];
+  }
+  const index = panelsArray.findIndex(panel => panel.current.id === id);
+  if (index < 0) {
+    return [null, null];
+  }
+  const isLastPanel = index === panelsArray.length - 1;
+  const idBefore = isLastPanel ? panelsArray[index - 1].current.id : id;
+  const idAfter = isLastPanel ? id : panelsArray[index + 1].current.id;
+  return [idBefore, idAfter];
+}
+function getAvailableGroupSizePixels(groupId) {
+  const panelGroupElement = getPanelGroup(groupId);
+  if (panelGroupElement == null) {
+    return NaN;
+  }
+  const direction = panelGroupElement.getAttribute("data-panel-group-direction");
+  const resizeHandles = getResizeHandlesForGroup(groupId);
+  if (direction === "horizontal") {
+    return panelGroupElement.offsetWidth - resizeHandles.reduce((accumulated, handle) => {
+      return accumulated + handle.offsetWidth;
+    }, 0);
+  } else {
+    return panelGroupElement.offsetHeight - resizeHandles.reduce((accumulated, handle) => {
+      return accumulated + handle.offsetHeight;
+    }, 0);
+  }
+}
+
+// This method returns a number between 1 and 100 representing
+// the % of the group's overall space this panel should occupy.
+function getFlexGrow(panels, id, sizes) {
+  if (panels.size === 1) {
+    return "100";
+  }
+  const panelsArray = panelsMapToSortedArray(panels);
+  const index = panelsArray.findIndex(panel => panel.current.id === id);
+  const size = sizes[index];
+  if (size == null) {
+    return "0";
+  }
+  return size.toPrecision(PRECISION);
+}
+function getPanel(id) {
+  const element = document.querySelector(`[data-panel-id="${id}"]`);
+  if (element) {
+    return element;
+  }
+  return null;
+}
+function getPanelGroup(id) {
+  const element = document.querySelector(`[data-panel-group-id="${id}"]`);
+  if (element) {
+    return element;
+  }
+  return null;
+}
+function getResizeHandle(id) {
+  const element = document.querySelector(`[data-panel-resize-handle-id="${id}"]`);
+  if (element) {
+    return element;
+  }
+  return null;
+}
+function getResizeHandleIndex(id) {
+  const handles = getResizeHandles();
+  const index = handles.findIndex(handle => handle.getAttribute("data-panel-resize-handle-id") === id);
+  return index ?? null;
+}
+function getResizeHandles() {
+  return Array.from(document.querySelectorAll(`[data-panel-resize-handle-id]`));
+}
+function getResizeHandlesForGroup(groupId) {
+  return Array.from(document.querySelectorAll(`[data-panel-resize-handle-id][data-panel-group-id="${groupId}"]`));
+}
+function getResizeHandlePanelIds(groupId, handleId, panelsArray) {
+  const handle = getResizeHandle(handleId);
+  const handles = getResizeHandlesForGroup(groupId);
+  const index = handle ? handles.indexOf(handle) : -1;
+  const idBefore = panelsArray[index]?.current?.id ?? null;
+  const idAfter = panelsArray[index + 1]?.current?.id ?? null;
+  return [idBefore, idAfter];
+}
+function panelsMapToSortedArray(panels) {
+  return Array.from(panels.values()).sort((panelA, panelB) => {
+    const orderA = panelA.current.order;
+    const orderB = panelB.current.order;
+    if (orderA == null && orderB == null) {
+      return 0;
+    } else if (orderA == null) {
+      return -1;
+    } else if (orderB == null) {
+      return 1;
+    } else {
+      return orderA - orderB;
+    }
+  });
+}
+function safeResizePanel(units, groupSizePixels, panel, prevSize, nextSize, event = null) {
+  let {
+    collapsedSize,
+    collapsible,
+    maxSize,
+    minSize
+  } = panel.current;
+  if (units === "pixels") {
+    collapsedSize = collapsedSize / groupSizePixels * 100;
+    if (maxSize != null) {
+      maxSize = maxSize / groupSizePixels * 100;
+    }
+    minSize = minSize / groupSizePixels * 100;
+  }
+  if (collapsible) {
+    if (prevSize > collapsedSize) {
+      // Mimic VS COde behavior; collapse a panel if it's smaller than half of its min-size
+      if (nextSize <= minSize / 2 + collapsedSize) {
+        return collapsedSize;
+      }
+    } else {
+      const isKeyboardEvent = event?.type?.startsWith("key");
+      if (!isKeyboardEvent) {
+        // Keyboard events should expand a collapsed panel to the min size,
+        // but mouse events should wait until the panel has reached its min size
+        // to avoid a visual flickering when dragging between collapsed and min size.
+        if (nextSize < minSize) {
+          return collapsedSize;
+        }
+      }
+    }
+  }
+  return Math.min(maxSize != null ? maxSize : 100, Math.max(minSize, nextSize));
+}
+function validatePanelProps(units, panelData) {
+  const {
+    collapsible,
+    defaultSize,
+    maxSize,
+    minSize
+  } = panelData.current;
+
+  // Basic props validation
+  if (minSize < 0 || units === "percentages" && minSize > 100) {
+    panelData.current.minSize = 0;
+  }
+  if (maxSize != null) {
+    if (maxSize < 0 || units === "percentages" && maxSize > 100) {
+      panelData.current.maxSize = null;
+    }
+  }
+  if (defaultSize !== null) {
+    if (defaultSize < 0 || units === "percentages" && defaultSize > 100) {
+      panelData.current.defaultSize = null;
+    } else if (defaultSize < minSize && !collapsible) {
+      panelData.current.defaultSize = minSize;
+    } else if (maxSize != null && defaultSize > maxSize) {
+      panelData.current.defaultSize = maxSize;
+    }
+  }
+}
+function validatePanelGroupLayout({
+  groupId,
+  panels,
+  nextSizes,
+  prevSizes,
+  units
+}) {
+  // Clone because this method modifies
+  nextSizes = [...nextSizes];
+  const panelsArray = panelsMapToSortedArray(panels);
+  const groupSizePixels = units === "pixels" ? getAvailableGroupSizePixels(groupId) : NaN;
+  let remainingSize = 0;
+
+  // First, check all of the proposed sizes against the min/max constraints
+  for (let index = 0; index < panelsArray.length; index++) {
+    const panel = panelsArray[index];
+    const prevSize = prevSizes[index];
+    const nextSize = nextSizes[index];
+    const safeNextSize = safeResizePanel(units, groupSizePixels, panel, prevSize, nextSize);
+    if (nextSize != safeNextSize) {
+      remainingSize += nextSize - safeNextSize;
+      nextSizes[index] = safeNextSize;
+    }
+  }
+
+  // If there is additional, left over space, assign it to any panel(s) that permits it
+  // (It's not worth taking multiple additional passes to evenly distribute)
+  if (remainingSize.toFixed(3) !== "0.000") {
+    for (let index = 0; index < panelsArray.length; index++) {
+      const panel = panelsArray[index];
+      let {
+        maxSize,
+        minSize
+      } = panel.current;
+      if (units === "pixels") {
+        minSize = minSize / groupSizePixels * 100;
+        if (maxSize != null) {
+          maxSize = maxSize / groupSizePixels * 100;
+        }
+      }
+      const size = Math.min(maxSize != null ? maxSize : 100, Math.max(minSize, nextSizes[index] + remainingSize));
+      if (size !== nextSizes[index]) {
+        remainingSize -= size - nextSizes[index];
+        nextSizes[index] = size;
+
+        // Fuzzy comparison to account for imprecise floating point math
+        if (Math.abs(remainingSize).toFixed(3) === "0.000") {
+          break;
+        }
+      }
+    }
+  }
+
+  // If we still have remainder, the requested layout wasn't valid and we should warn about it
+  if (remainingSize.toFixed(3) !== "0.000") ;
+  return nextSizes;
+}
+
+function assert(expectedCondition, message = "Assertion failed!") {
+  if (!expectedCondition) {
+    console.error(message);
+    throw Error(message);
+  }
+}
+
+// https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/
+
+function useWindowSplitterPanelGroupBehavior({
+  committedValuesRef,
+  groupId,
+  panels,
+  setSizes,
+  sizes,
+  panelSizeBeforeCollapse
+}) {
+  useEffect(() => {
+    const {
+      direction,
+      panels
+    } = committedValuesRef.current;
+    const groupElement = getPanelGroup(groupId);
+    assert(groupElement != null, `No group found for id "${groupId}"`);
+    const {
+      height,
+      width
+    } = groupElement.getBoundingClientRect();
+    const handles = getResizeHandlesForGroup(groupId);
+    const cleanupFunctions = handles.map(handle => {
+      const handleId = handle.getAttribute("data-panel-resize-handle-id");
+      const panelsArray = panelsMapToSortedArray(panels);
+      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelsArray);
+      if (idBefore == null || idAfter == null) {
+        return () => {};
+      }
+      let currentMinSize = 0;
+      let currentMaxSize = 100;
+      let totalMinSize = 0;
+      let totalMaxSize = 0;
+
+      // A panel's effective min/max sizes also need to account for other panel's sizes.
+      panelsArray.forEach(panelData => {
+        const {
+          id,
+          maxSize,
+          minSize
+        } = panelData.current;
+        if (id === idBefore) {
+          currentMinSize = minSize;
+          currentMaxSize = maxSize != null ? maxSize : 100;
+        } else {
+          totalMinSize += minSize;
+          totalMaxSize += maxSize != null ? maxSize : 100;
+        }
+      });
+      const ariaValueMax = Math.min(currentMaxSize, 100 - totalMinSize);
+      const ariaValueMin = Math.max(currentMinSize, (panelsArray.length - 1) * 100 - totalMaxSize);
+      const flexGrow = getFlexGrow(panels, idBefore, sizes);
+      handle.setAttribute("aria-valuemax", "" + Math.round(ariaValueMax));
+      handle.setAttribute("aria-valuemin", "" + Math.round(ariaValueMin));
+      handle.setAttribute("aria-valuenow", "" + Math.round(parseInt(flexGrow)));
+      const onKeyDown = event => {
+        if (event.defaultPrevented) {
+          return;
+        }
+        switch (event.key) {
+          case "Enter":
+            {
+              event.preventDefault();
+              const index = panelsArray.findIndex(panel => panel.current.id === idBefore);
+              if (index >= 0) {
+                const panelData = panelsArray[index];
+                const size = sizes[index];
+                if (size != null) {
+                  let delta = 0;
+                  if (size.toPrecision(PRECISION) <= panelData.current.minSize.toPrecision(PRECISION)) {
+                    delta = direction === "horizontal" ? width : height;
+                  } else {
+                    delta = -(direction === "horizontal" ? width : height);
+                  }
+                  const nextSizes = adjustByDelta(event, committedValuesRef.current, idBefore, idAfter, delta, sizes, panelSizeBeforeCollapse.current, null);
+                  if (sizes !== nextSizes) {
+                    setSizes(nextSizes);
+                  }
+                }
+              }
+              break;
+            }
+        }
+      };
+      handle.addEventListener("keydown", onKeyDown);
+      const panelBefore = getPanel(idBefore);
+      if (panelBefore != null) {
+        handle.setAttribute("aria-controls", panelBefore.id);
+      }
+      return () => {
+        handle.removeAttribute("aria-valuemax");
+        handle.removeAttribute("aria-valuemin");
+        handle.removeAttribute("aria-valuenow");
+        handle.removeEventListener("keydown", onKeyDown);
+        if (panelBefore != null) {
+          handle.removeAttribute("aria-controls");
+        }
+      };
+    });
+    return () => {
+      cleanupFunctions.forEach(cleanupFunction => cleanupFunction());
+    };
+  }, [committedValuesRef, groupId, panels, panelSizeBeforeCollapse, setSizes, sizes]);
+}
+function useWindowSplitterResizeHandlerBehavior({
+  disabled,
+  handleId,
+  resizeHandler
+}) {
+  useEffect(() => {
+    if (disabled || resizeHandler == null) {
+      return;
+    }
+    const handleElement = getResizeHandle(handleId);
+    if (handleElement == null) {
+      return;
+    }
+    const onKeyDown = event => {
+      if (event.defaultPrevented) {
+        return;
+      }
+      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 handles = getResizeHandles();
+            const index = getResizeHandleIndex(handleId);
+            assert(index !== null);
+            const nextIndex = event.shiftKey ? index > 0 ? index - 1 : handles.length - 1 : index + 1 < handles.length ? index + 1 : 0;
+            const nextHandle = handles[nextIndex];
+            nextHandle.focus();
+            break;
+          }
+      }
+    };
+    handleElement.addEventListener("keydown", onKeyDown);
+    return () => {
+      handleElement.removeEventListener("keydown", onKeyDown);
+    };
+  }, [disabled, handleId, resizeHandler]);
+}
+
+function areEqual(arrayA, arrayB) {
+  if (arrayA.length !== arrayB.length) {
+    return false;
+  }
+  for (let index = 0; index < arrayA.length; index++) {
+    if (arrayA[index] !== arrayB[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function getDragOffset(event, handleId, direction, initialOffset = 0, initialHandleElementRect = null) {
+  const isHorizontal = direction === "horizontal";
+  let pointerOffset = 0;
+  if (isMouseEvent(event)) {
+    pointerOffset = isHorizontal ? event.clientX : event.clientY;
+  } else if (isTouchEvent(event)) {
+    const firstTouch = event.touches[0];
+    pointerOffset = isHorizontal ? firstTouch.screenX : firstTouch.screenY;
+  } else {
+    return 0;
+  }
+  const handleElement = getResizeHandle(handleId);
+  const rect = initialHandleElementRect || handleElement.getBoundingClientRect();
+  const elementOffset = isHorizontal ? rect.left : rect.top;
+  return pointerOffset - elementOffset - initialOffset;
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX
+function getMovement(event, groupId, handleId, panelsArray, direction, prevSizes, initialDragState) {
+  const {
+    dragOffset = 0,
+    dragHandleRect,
+    sizes: initialSizes
+  } = initialDragState || {};
+
+  // If we're resizing by mouse or touch, use the initial sizes as a base.
+  // This has the benefit of causing force-collapsed panels to spring back open if drag is reversed.
+  const baseSizes = initialSizes || prevSizes;
+  if (isKeyDown(event)) {
+    const isHorizontal = direction === "horizontal";
+    const groupElement = getPanelGroup(groupId);
+    const rect = groupElement.getBoundingClientRect();
+    const groupSizeInPixels = isHorizontal ? rect.width : rect.height;
+    const denominator = event.shiftKey ? 10 : 100;
+    const delta = groupSizeInPixels / denominator;
+    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 = groupSizeInPixels;
+        break;
+      case "Home":
+        movement = -groupSizeInPixels;
+        break;
+    }
+
+    // If the Panel being resized is collapsible,
+    // we need to special case resizing around the minSize boundary.
+    // If contracting, Panels should shrink to their minSize and then snap to fully collapsed.
+    // If expanding from collapsed, they should snap back to their minSize.
+    const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelsArray);
+    const targetPanelId = movement < 0 ? idBefore : idAfter;
+    const targetPanelIndex = panelsArray.findIndex(panel => panel.current.id === targetPanelId);
+    const targetPanel = panelsArray[targetPanelIndex];
+    if (targetPanel.current.collapsible) {
+      const baseSize = baseSizes[targetPanelIndex];
+      if (baseSize === 0 || baseSize.toPrecision(PRECISION) === targetPanel.current.minSize.toPrecision(PRECISION)) {
+        movement = movement < 0 ? -targetPanel.current.minSize * groupSizeInPixels : targetPanel.current.minSize * groupSizeInPixels;
+      }
+    }
+    return movement;
+  } else {
+    return getDragOffset(event, handleId, direction, dragOffset, dragHandleRect);
+  }
+}
+function isKeyDown(event) {
+  return event.type === "keydown";
+}
+function isMouseEvent(event) {
+  return event.type.startsWith("mouse");
+}
+function isTouchEvent(event) {
+  return event.type.startsWith("touch");
+}
+
+let currentState = null;
+let element = null;
+function getCursorStyle(state) {
+  switch (state) {
+    case "horizontal":
+      return "ew-resize";
+    case "horizontal-max":
+      return "w-resize";
+    case "horizontal-min":
+      return "e-resize";
+    case "vertical":
+      return "ns-resize";
+    case "vertical-max":
+      return "n-resize";
+    case "vertical-min":
+      return "s-resize";
+  }
+}
+function resetGlobalCursorStyle() {
+  if (element !== null) {
+    document.head.removeChild(element);
+    currentState = null;
+    element = null;
+  }
+}
+function setGlobalCursorStyle(state) {
+  if (currentState === state) {
+    return;
+  }
+  currentState = state;
+  const style = getCursorStyle(state);
+  if (element === null) {
+    element = document.createElement("style");
+    document.head.appendChild(element);
+  }
+  element.innerHTML = `*{cursor: ${style}!important;}`;
+}
+
+function debounce(callback, durationMs = 10) {
+  let timeoutId = null;
+  let callable = (...args) => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      callback(...args);
+    }, durationMs);
+  };
+  return callable;
+}
+
+// Note that Panel ids might be user-provided (stable) or useId generated (non-deterministic)
+// so they should not be used as part of the serialization key.
+// Using an attribute like minSize instead should work well enough.
+// Pre-sorting by minSize allows remembering layouts even if panels are re-ordered/dragged.
+function getSerializationKey(panels) {
+  return panels.map(panel => {
+    const {
+      minSize,
+      order
+    } = panel.current;
+    return order ? `${order}:${minSize}` : `${minSize}`;
+  }).sort((a, b) => a.localeCompare(b)).join(",");
+}
+function loadSerializedPanelGroupState(autoSaveId, storage) {
+  try {
+    const serialized = storage.getItem(`PanelGroup:sizes:${autoSaveId}`);
+    if (serialized) {
+      const parsed = JSON.parse(serialized);
+      if (typeof parsed === "object" && parsed != null) {
+        return parsed;
+      }
+    }
+  } catch (error) {}
+  return null;
+}
+function loadPanelLayout(autoSaveId, panels, storage) {
+  const state = loadSerializedPanelGroupState(autoSaveId, storage);
+  if (state) {
+    const key = getSerializationKey(panels);
+    return state[key] ?? null;
+  }
+  return null;
+}
+function savePanelGroupLayout(autoSaveId, panels, sizes, storage) {
+  const key = getSerializationKey(panels);
+  const state = loadSerializedPanelGroupState(autoSaveId, storage) || {};
+  state[key] = sizes;
+  try {
+    storage.setItem(`PanelGroup:sizes:${autoSaveId}`, JSON.stringify(state));
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+const debounceMap = {};
+
+// PanelGroup might be rendering in a server-side environment where localStorage is not available
+// or on a browser with cookies/storage disabled.
+// In either case, this function avoids accessing localStorage until needed,
+// and avoids throwing user-visible errors.
+function initializeDefaultStorage(storageObject) {
+  try {
+    if (typeof localStorage !== "undefined") {
+      // Bypass this check for future calls
+      storageObject.getItem = name => {
+        return 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 = () => {};
+  }
+}
+const defaultStorage = {
+  getItem: name => {
+    initializeDefaultStorage(defaultStorage);
+    return defaultStorage.getItem(name);
+  },
+  setItem: (name, value) => {
+    initializeDefaultStorage(defaultStorage);
+    defaultStorage.setItem(name, value);
+  }
+};
+
+// Initial drag state serves a few purposes:
+// * dragOffset:
+//   Resize is calculated by the distance between the current pointer event and the resize handle being "dragged"
+//   This value accounts for the initial offset when the touch/click starts, so the handle doesn't appear to "jump"
+// * dragHandleRect, sizes:
+//   When resizing is done via mouse/touch event– some initial state is stored
+//   so that any panels that contract will also expand if drag direction is reversed.
+function PanelGroupWithForwardedRef({
+  autoSaveId,
+  children = null,
+  className: classNameFromProps = "",
+  direction,
+  disablePointerEventsDuringResize = false,
+  forwardedRef,
+  id: idFromProps = null,
+  onLayout,
+  storage = defaultStorage,
+  style: styleFromProps = {},
+  tagName: Type = "div",
+  units = "percentages"
+}) {
+  const groupId = useUniqueId(idFromProps);
+  const [activeHandleId, setActiveHandleId] = useState(null);
+  const [panels, setPanels] = useState(new Map());
+
+  // When resizing is done via mouse/touch event–
+  // We store the initial Panel sizes in this ref, and apply move deltas to them instead of to the current sizes.
+  // This has the benefit of causing force-collapsed panels to spring back open if drag is reversed.
+  const initialDragStateRef = useRef(null);
+  useRef({
+    didLogDefaultSizeWarning: false,
+    didLogIdAndOrderWarning: false,
+    didLogInvalidLayoutWarning: false,
+    prevPanelIds: []
+  });
+
+  // Use a ref to guard against users passing inline props
+  const callbacksRef = useRef({
+    onLayout
+  });
+  useEffect(() => {
+    callbacksRef.current.onLayout = onLayout;
+  });
+  const panelIdToLastNotifiedSizeMapRef = useRef({});
+
+  // 0-1 values representing the relative size of each panel.
+  const [sizes, setSizes] = useState([]);
+
+  // Used to support imperative collapse/expand API.
+  const panelSizeBeforeCollapse = useRef(new Map());
+  const prevDeltaRef = useRef(0);
+
+  // Store committed values to avoid unnecessarily re-running memoization/effects functions.
+  const committedValuesRef = useRef({
+    direction,
+    id: groupId,
+    panels,
+    sizes,
+    units
+  });
+  useImperativeHandle(forwardedRef, () => ({
+    getId: () => groupId,
+    getLayout: unitsFromParams => {
+      const {
+        sizes,
+        units: unitsFromProps
+      } = committedValuesRef.current;
+      const units = unitsFromParams ?? unitsFromProps;
+      if (units === "pixels") {
+        const groupSizePixels = getAvailableGroupSizePixels(groupId);
+        return sizes.map(size => size / 100 * groupSizePixels);
+      } else {
+        return sizes;
+      }
+    },
+    setLayout: (sizes, unitsFromParams) => {
+      const {
+        id: groupId,
+        panels,
+        sizes: prevSizes,
+        units
+      } = committedValuesRef.current;
+      if ((unitsFromParams || units) === "pixels") {
+        const groupSizePixels = getAvailableGroupSizePixels(groupId);
+        sizes = sizes.map(size => size / groupSizePixels * 100);
+      }
+      const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+      const panelsArray = panelsMapToSortedArray(panels);
+      const nextSizes = validatePanelGroupLayout({
+        groupId,
+        panels,
+        nextSizes: sizes,
+        prevSizes,
+        units
+      });
+      if (!areEqual(prevSizes, nextSizes)) {
+        setSizes(nextSizes);
+        callPanelCallbacks(panelsArray, nextSizes, panelIdToLastNotifiedSizeMap);
+      }
+    }
+  }), [groupId]);
+  useIsomorphicLayoutEffect(() => {
+    committedValuesRef.current.direction = direction;
+    committedValuesRef.current.id = groupId;
+    committedValuesRef.current.panels = panels;
+    committedValuesRef.current.sizes = sizes;
+    committedValuesRef.current.units = units;
+  });
+  useWindowSplitterPanelGroupBehavior({
+    committedValuesRef,
+    groupId,
+    panels,
+    setSizes,
+    sizes,
+    panelSizeBeforeCollapse
+  });
+
+  // Notify external code when sizes have changed.
+  useEffect(() => {
+    const {
+      onLayout
+    } = callbacksRef.current;
+    const {
+      panels,
+      sizes
+    } = committedValuesRef.current;
+
+    // Don't commit layout until all panels have registered and re-rendered with their actual sizes.
+    if (sizes.length > 0) {
+      if (onLayout) {
+        onLayout(sizes);
+      }
+      const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+
+      // When possible, we notify before the next render so that rendering work can be batched together.
+      // Some cases are difficult to detect though,
+      // for example– panels that are conditionally rendered can affect the size of neighboring panels.
+      // In this case, the best we can do is notify on commit.
+      // The callPanelCallbacks() uses its own memoization to avoid notifying panels twice in these cases.
+      const panelsArray = panelsMapToSortedArray(panels);
+      callPanelCallbacks(panelsArray, sizes, panelIdToLastNotifiedSizeMap);
+    }
+  }, [sizes]);
+
+  // Once all panels have registered themselves,
+  // Compute the initial sizes based on default weights.
+  // This assumes that panels register during initial mount (no conditional rendering)!
+  useIsomorphicLayoutEffect(() => {
+    const {
+      id: groupId,
+      sizes,
+      units
+    } = committedValuesRef.current;
+    if (sizes.length === panels.size) {
+      // Only compute (or restore) default sizes once per panel configuration.
+      return;
+    }
+
+    // If this panel has been configured to persist sizing information,
+    // default size should be restored from local storage if possible.
+    let defaultSizes = null;
+    if (autoSaveId) {
+      const panelsArray = panelsMapToSortedArray(panels);
+      defaultSizes = loadPanelLayout(autoSaveId, panelsArray, storage);
+    }
+    if (defaultSizes != null) {
+      // Validate saved sizes in case something has changed since last render
+      // e.g. for pixel groups, this could be the size of the window
+      const validatedSizes = validatePanelGroupLayout({
+        groupId,
+        panels,
+        nextSizes: defaultSizes,
+        prevSizes: defaultSizes,
+        units
+      });
+      setSizes(validatedSizes);
+    } else {
+      const sizes = calculateDefaultLayout({
+        groupId,
+        panels,
+        units
+      });
+      setSizes(sizes);
+    }
+  }, [autoSaveId, panels, storage]);
+  useEffect(() => {
+    // If this panel has been configured to persist sizing information, save sizes to local storage.
+    if (autoSaveId) {
+      if (sizes.length === 0 || sizes.length !== panels.size) {
+        return;
+      }
+      const panelsArray = panelsMapToSortedArray(panels);
+
+      // Limit the frequency of localStorage updates.
+      if (!debounceMap[autoSaveId]) {
+        debounceMap[autoSaveId] = debounce(savePanelGroupLayout, 100);
+      }
+      debounceMap[autoSaveId](autoSaveId, panelsArray, sizes, storage);
+    }
+  }, [autoSaveId, panels, sizes, storage]);
+  useIsomorphicLayoutEffect(() => {
+    // Pixel panel constraints need to be reassessed after a group resize
+    // We can avoid the ResizeObserver overhead for relative layouts
+    if (units === "pixels") {
+      const resizeObserver = new ResizeObserver(() => {
+        const {
+          panels,
+          sizes: prevSizes
+        } = committedValuesRef.current;
+        const nextSizes = validatePanelGroupLayout({
+          groupId,
+          panels,
+          nextSizes: prevSizes,
+          prevSizes,
+          units
+        });
+        if (!areEqual(prevSizes, nextSizes)) {
+          setSizes(nextSizes);
+        }
+      });
+      resizeObserver.observe(getPanelGroup(groupId));
+      return () => {
+        resizeObserver.disconnect();
+      };
+    }
+  }, [groupId, units]);
+  const getPanelSize = useCallback((id, unitsFromParams) => {
+    const {
+      panels,
+      units: unitsFromProps
+    } = committedValuesRef.current;
+    const panelsArray = panelsMapToSortedArray(panels);
+    const index = panelsArray.findIndex(panel => panel.current.id === id);
+    const size = sizes[index];
+    const units = unitsFromParams ?? unitsFromProps;
+    if (units === "pixels") {
+      const groupSizePixels = getAvailableGroupSizePixels(groupId);
+      return size / 100 * groupSizePixels;
+    } else {
+      return size;
+    }
+  }, [groupId, sizes]);
+  const getPanelStyle = useCallback((id, defaultSize) => {
+    const {
+      panels
+    } = committedValuesRef.current;
+
+    // Before mounting, Panels will not yet have registered themselves.
+    // This includes server rendering.
+    // At this point the best we can do is render everything with the same size.
+    if (panels.size === 0) {
+      return {
+        flexBasis: 0,
+        flexGrow: defaultSize != null ? defaultSize : undefined,
+        flexShrink: 1,
+        // Without this, Panel sizes may be unintentionally overridden by their content.
+        overflow: "hidden"
+      };
+    }
+    const flexGrow = getFlexGrow(panels, id, sizes);
+    return {
+      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: disablePointerEventsDuringResize && activeHandleId !== null ? "none" : undefined
+    };
+  }, [activeHandleId, disablePointerEventsDuringResize, sizes]);
+  const registerPanel = useCallback((id, panelRef) => {
+    const {
+      units
+    } = committedValuesRef.current;
+    validatePanelProps(units, panelRef);
+    setPanels(prevPanels => {
+      if (prevPanels.has(id)) {
+        return prevPanels;
+      }
+      const nextPanels = new Map(prevPanels);
+      nextPanels.set(id, panelRef);
+      return nextPanels;
+    });
+  }, []);
+  const registerResizeHandle = useCallback(handleId => {
+    const resizeHandler = event => {
+      event.preventDefault();
+      const {
+        direction,
+        panels,
+        sizes: prevSizes
+      } = committedValuesRef.current;
+      const panelsArray = panelsMapToSortedArray(panels);
+      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelsArray);
+      if (idBefore == null || idAfter == null) {
+        return;
+      }
+      let movement = getMovement(event, groupId, handleId, panelsArray, direction, prevSizes, initialDragStateRef.current);
+      if (movement === 0) {
+        return;
+      }
+      const groupElement = getPanelGroup(groupId);
+      const rect = groupElement.getBoundingClientRect();
+      const isHorizontal = direction === "horizontal";
+
+      // Support RTL layouts
+      if (document.dir === "rtl" && isHorizontal) {
+        movement = -movement;
+      }
+      const size = isHorizontal ? rect.width : rect.height;
+      const delta = movement / size * 100;
+
+      // If a validateLayout method has been provided
+      // it's important to use it before updating the mouse cursor
+      const nextSizes = adjustByDelta(event, committedValuesRef.current, idBefore, idAfter, delta, prevSizes, panelSizeBeforeCollapse.current, initialDragStateRef.current);
+      const sizesChanged = !areEqual(prevSizes, nextSizes);
+
+      // Don't update cursor for resizes triggered by keyboard interactions.
+      if (isMouseEvent(event) || isTouchEvent(event)) {
+        // Watch for multiple subsequent deltas; this might occur for tiny cursor movements.
+        // In this case, Panel sizes might not change–
+        // but updating cursor in this scenario would cause a flicker.
+        if (prevDeltaRef.current != delta) {
+          if (!sizesChanged) {
+            // If the pointer has moved too far to resize the panel any further,
+            // update the cursor style for a visual clue.
+            // This mimics VS Code behavior.
+
+            if (isHorizontal) {
+              setGlobalCursorStyle(movement < 0 ? "horizontal-min" : "horizontal-max");
+            } else {
+              setGlobalCursorStyle(movement < 0 ? "vertical-min" : "vertical-max");
+            }
+          } else {
+            // Reset the cursor style to the the normal resize cursor.
+            setGlobalCursorStyle(isHorizontal ? "horizontal" : "vertical");
+          }
+        }
+      }
+      if (sizesChanged) {
+        const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+
+        // It's okay to bypass in this case because we already validated above
+        setSizes(nextSizes);
+
+        // If resize change handlers have been declared, this is the time to call them.
+        // Trigger user callbacks after updating state, so that user code can override the sizes.
+        callPanelCallbacks(panelsArray, nextSizes, panelIdToLastNotifiedSizeMap);
+      }
+      prevDeltaRef.current = delta;
+    };
+    return resizeHandler;
+  }, [groupId]);
+  const unregisterPanel = useCallback(id => {
+    setPanels(prevPanels => {
+      if (!prevPanels.has(id)) {
+        return prevPanels;
+      }
+      const nextPanels = new Map(prevPanels);
+      nextPanels.delete(id);
+      return nextPanels;
+    });
+  }, []);
+  const collapsePanel = useCallback(id => {
+    const {
+      panels,
+      sizes: prevSizes
+    } = committedValuesRef.current;
+    const panel = panels.get(id);
+    if (panel == null) {
+      return;
+    }
+    const {
+      collapsedSize,
+      collapsible
+    } = panel.current;
+    if (!collapsible) {
+      return;
+    }
+    const panelsArray = panelsMapToSortedArray(panels);
+    const index = panelsArray.indexOf(panel);
+    if (index < 0) {
+      return;
+    }
+    const currentSize = prevSizes[index];
+    if (currentSize === collapsedSize) {
+      // Panel is already collapsed.
+      return;
+    }
+    panelSizeBeforeCollapse.current.set(id, currentSize);
+    const [idBefore, idAfter] = getBeforeAndAfterIds(id, panelsArray);
+    if (idBefore == null || idAfter == null) {
+      return;
+    }
+    const isLastPanel = index === panelsArray.length - 1;
+    const delta = isLastPanel ? currentSize : collapsedSize - currentSize;
+    const nextSizes = adjustByDelta(null, committedValuesRef.current, idBefore, idAfter, delta, prevSizes, panelSizeBeforeCollapse.current, null);
+    if (prevSizes !== nextSizes) {
+      const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+      setSizes(nextSizes);
+
+      // If resize change handlers have been declared, this is the time to call them.
+      // Trigger user callbacks after updating state, so that user code can override the sizes.
+      callPanelCallbacks(panelsArray, nextSizes, panelIdToLastNotifiedSizeMap);
+    }
+  }, []);
+  const expandPanel = useCallback(id => {
+    const {
+      panels,
+      sizes: prevSizes
+    } = committedValuesRef.current;
+    const panel = panels.get(id);
+    if (panel == null) {
+      return;
+    }
+    const {
+      collapsedSize,
+      minSize
+    } = panel.current;
+    const sizeBeforeCollapse = panelSizeBeforeCollapse.current.get(id) || minSize;
+    if (!sizeBeforeCollapse) {
+      return;
+    }
+    const panelsArray = panelsMapToSortedArray(panels);
+    const index = panelsArray.indexOf(panel);
+    if (index < 0) {
+      return;
+    }
+    const currentSize = prevSizes[index];
+    if (currentSize !== collapsedSize) {
+      // Panel is already expanded.
+      return;
+    }
+    const [idBefore, idAfter] = getBeforeAndAfterIds(id, panelsArray);
+    if (idBefore == null || idAfter == null) {
+      return;
+    }
+    const isLastPanel = index === panelsArray.length - 1;
+    const delta = isLastPanel ? collapsedSize - sizeBeforeCollapse : sizeBeforeCollapse;
+    const nextSizes = adjustByDelta(null, committedValuesRef.current, idBefore, idAfter, delta, prevSizes, panelSizeBeforeCollapse.current, null);
+    if (prevSizes !== nextSizes) {
+      const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+      setSizes(nextSizes);
+
+      // If resize change handlers have been declared, this is the time to call them.
+      // Trigger user callbacks after updating state, so that user code can override the sizes.
+      callPanelCallbacks(panelsArray, nextSizes, panelIdToLastNotifiedSizeMap);
+    }
+  }, []);
+  const resizePanel = useCallback((id, nextSize, unitsFromParams) => {
+    const {
+      id: groupId,
+      panels,
+      sizes: prevSizes,
+      units
+    } = committedValuesRef.current;
+    if ((unitsFromParams || units) === "pixels") {
+      const groupSizePixels = getAvailableGroupSizePixels(groupId);
+      nextSize = nextSize / groupSizePixels * 100;
+    }
+    const panel = panels.get(id);
+    if (panel == null) {
+      return;
+    }
+    let {
+      collapsedSize,
+      collapsible,
+      maxSize,
+      minSize
+    } = panel.current;
+    if (units === "pixels") {
+      const groupSizePixels = getAvailableGroupSizePixels(groupId);
+      minSize = minSize / groupSizePixels * 100;
+      if (maxSize != null) {
+        maxSize = maxSize / groupSizePixels * 100;
+      }
+    }
+    const panelsArray = panelsMapToSortedArray(panels);
+    const index = panelsArray.indexOf(panel);
+    if (index < 0) {
+      return;
+    }
+    const currentSize = prevSizes[index];
+    if (currentSize === nextSize) {
+      return;
+    }
+    if (collapsible && nextSize === collapsedSize) ; else {
+      nextSize = Math.min(maxSize != null ? maxSize : 100, Math.max(minSize, nextSize));
+    }
+    const [idBefore, idAfter] = getBeforeAndAfterIds(id, panelsArray);
+    if (idBefore == null || idAfter == null) {
+      return;
+    }
+    const isLastPanel = index === panelsArray.length - 1;
+    const delta = isLastPanel ? currentSize - nextSize : nextSize - currentSize;
+    const nextSizes = adjustByDelta(null, committedValuesRef.current, idBefore, idAfter, delta, prevSizes, panelSizeBeforeCollapse.current, null);
+    if (prevSizes !== nextSizes) {
+      const panelIdToLastNotifiedSizeMap = panelIdToLastNotifiedSizeMapRef.current;
+      setSizes(nextSizes);
+
+      // If resize change handlers have been declared, this is the time to call them.
+      // Trigger user callbacks after updating state, so that user code can override the sizes.
+      callPanelCallbacks(panelsArray, nextSizes, panelIdToLastNotifiedSizeMap);
+    }
+  }, []);
+  const context = useMemo(() => ({
+    activeHandleId,
+    collapsePanel,
+    direction,
+    expandPanel,
+    getPanelSize,
+    getPanelStyle,
+    groupId,
+    registerPanel,
+    registerResizeHandle,
+    resizePanel,
+    startDragging: (id, event) => {
+      setActiveHandleId(id);
+      if (isMouseEvent(event) || isTouchEvent(event)) {
+        const handleElement = getResizeHandle(id);
+        initialDragStateRef.current = {
+          dragHandleRect: handleElement.getBoundingClientRect(),
+          dragOffset: getDragOffset(event, id, direction),
+          sizes: committedValuesRef.current.sizes
+        };
+      }
+    },
+    stopDragging: () => {
+      resetGlobalCursorStyle();
+      setActiveHandleId(null);
+      initialDragStateRef.current = null;
+    },
+    units,
+    unregisterPanel
+  }), [activeHandleId, collapsePanel, direction, expandPanel, getPanelSize, getPanelStyle, groupId, registerPanel, registerResizeHandle, resizePanel, units, unregisterPanel]);
+  const style = {
+    display: "flex",
+    flexDirection: direction === "horizontal" ? "row" : "column",
+    height: "100%",
+    overflow: "hidden",
+    width: "100%"
+  };
+  return createElement(PanelGroupContext.Provider, {
+    children: createElement(Type, {
+      children,
+      className: classNameFromProps,
+      "data-panel-group": "",
+      "data-panel-group-direction": direction,
+      "data-panel-group-id": groupId,
+      "data-panel-group-units": units,
+      style: {
+        ...style,
+        ...styleFromProps
+      }
+    }),
+    value: context
+  });
+}
+const PanelGroup = forwardRef((props, ref) => createElement(PanelGroupWithForwardedRef, {
+  ...props,
+  forwardedRef: ref
+}));
+PanelGroupWithForwardedRef.displayName = "PanelGroup";
+PanelGroup.displayName = "forwardRef(PanelGroup)";
+
+function PanelResizeHandle({
+  children = null,
+  className: classNameFromProps = "",
+  disabled = false,
+  id: idFromProps = null,
+  onDragging,
+  style: styleFromProps = {},
+  tagName: Type = "div"
+}) {
+  const divElementRef = useRef(null);
+
+  // Use a ref to guard against users passing inline props
+  const 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 {
+    activeHandleId,
+    direction,
+    groupId,
+    registerResizeHandle,
+    startDragging,
+    stopDragging
+  } = panelGroupContext;
+  const resizeHandleId = useUniqueId(idFromProps);
+  const isDragging = activeHandleId === resizeHandleId;
+  const [isFocused, setIsFocused] = useState(false);
+  const [resizeHandler, setResizeHandler] = useState(null);
+  const stopDraggingAndBlur = useCallback(() => {
+    // Clicking on the drag handle shouldn't leave it focused;
+    // That would cause the PanelGroup to think it was still active.
+    const div = divElementRef.current;
+    div.blur();
+    stopDragging();
+    const {
+      onDragging
+    } = callbacksRef.current;
+    if (onDragging) {
+      onDragging(false);
+    }
+  }, [stopDragging]);
+  useEffect(() => {
+    if (disabled) {
+      setResizeHandler(null);
+    } else {
+      const resizeHandler = registerResizeHandle(resizeHandleId);
+      setResizeHandler(() => resizeHandler);
+    }
+  }, [disabled, resizeHandleId, registerResizeHandle]);
+  useEffect(() => {
+    if (disabled || resizeHandler == null || !isDragging) {
+      return;
+    }
+    const onMove = event => {
+      resizeHandler(event);
+    };
+    const onMouseLeave = event => {
+      resizeHandler(event);
+    };
+    const divElement = divElementRef.current;
+    const targetDocument = divElement.ownerDocument;
+    targetDocument.body.addEventListener("contextmenu", stopDraggingAndBlur);
+    targetDocument.body.addEventListener("mousemove", onMove);
+    targetDocument.body.addEventListener("touchmove", onMove);
+    targetDocument.body.addEventListener("mouseleave", onMouseLeave);
+    window.addEventListener("mouseup", stopDraggingAndBlur);
+    window.addEventListener("touchend", stopDraggingAndBlur);
+    return () => {
+      targetDocument.body.removeEventListener("contextmenu", stopDraggingAndBlur);
+      targetDocument.body.removeEventListener("mousemove", onMove);
+      targetDocument.body.removeEventListener("touchmove", onMove);
+      targetDocument.body.removeEventListener("mouseleave", onMouseLeave);
+      window.removeEventListener("mouseup", stopDraggingAndBlur);
+      window.removeEventListener("touchend", stopDraggingAndBlur);
+    };
+  }, [direction, disabled, isDragging, resizeHandler, stopDraggingAndBlur]);
+  useWindowSplitterResizeHandlerBehavior({
+    disabled,
+    handleId: resizeHandleId,
+    resizeHandler
+  });
+  const style = {
+    cursor: getCursorStyle(direction),
+    touchAction: "none",
+    userSelect: "none"
+  };
+  return createElement(Type, {
+    children,
+    className: classNameFromProps,
+    "data-resize-handle-active": isDragging ? "pointer" : isFocused ? "keyboard" : undefined,
+    "data-panel-group-direction": direction,
+    "data-panel-group-id": groupId,
+    "data-panel-resize-handle-enabled": !disabled,
+    "data-panel-resize-handle-id": resizeHandleId,
+    onBlur: () => setIsFocused(false),
+    onFocus: () => setIsFocused(true),
+    onMouseDown: event => {
+      startDragging(resizeHandleId, event.nativeEvent);
+      const {
+        onDragging
+      } = callbacksRef.current;
+      if (onDragging) {
+        onDragging(true);
+      }
+    },
+    onMouseUp: stopDraggingAndBlur,
+    onTouchCancel: stopDraggingAndBlur,
+    onTouchEnd: stopDraggingAndBlur,
+    onTouchStart: event => {
+      startDragging(resizeHandleId, event.nativeEvent);
+      const {
+        onDragging
+      } = callbacksRef.current;
+      if (onDragging) {
+        onDragging(true);
+      }
+    },
+    ref: divElementRef,
+    role: "separator",
+    style: {
+      ...style,
+      ...styleFromProps
+    },
+    tabIndex: 0
+  });
+}
+PanelResizeHandle.displayName = "PanelResizeHandle";
+
+export { Panel, PanelGroup, PanelResizeHandle, getAvailableGroupSizePixels };