{"version":3,"file":"react-resizable-panels-BpzDQ8O-.js","sources":["../../node_modules/react-resizable-panels/dist/react-resizable-panels.browser.esm.js"],"sourcesContent":["import * as React from 'react';\n\n// This module exists to work around Webpack issue https://github.com/webpack/webpack/issues/14814\n\n// eslint-disable-next-line no-restricted-imports\n\nconst {\n  createElement,\n  createContext,\n  createRef,\n  forwardRef,\n  useCallback,\n  useContext,\n  useEffect,\n  useImperativeHandle,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState\n} = React;\n\n// `Math.random()` and `.slice(0, 5)` prevents bundlers from trying to `import { useId } from 'react'`\nconst useId = React[`useId${Math.random()}`.slice(0, 5)];\nconst useLayoutEffect_do_not_use_directly = useLayoutEffect;\n\n// The \"contextmenu\" event is not supported as a PointerEvent in all browsers yet, so MouseEvent still need to be handled\n\nconst PanelGroupContext = createContext(null);\nPanelGroupContext.displayName = \"PanelGroupContext\";\n\nconst useIsomorphicLayoutEffect = useLayoutEffect_do_not_use_directly ;\n\nconst wrappedUseId = typeof useId === \"function\" ? useId : () => null;\nlet counter = 0;\nfunction useUniqueId(idFromParams = null) {\n  const idFromUseId = wrappedUseId();\n  const idRef = useRef(idFromParams || idFromUseId || null);\n  if (idRef.current === null) {\n    idRef.current = \"\" + counter++;\n  }\n  return idFromParams !== null && idFromParams !== void 0 ? idFromParams : idRef.current;\n}\n\nfunction PanelWithForwardedRef({\n  children,\n  className: classNameFromProps = \"\",\n  collapsedSize,\n  collapsible,\n  defaultSize,\n  forwardedRef,\n  id: idFromProps,\n  maxSize,\n  minSize,\n  onCollapse,\n  onExpand,\n  onResize,\n  order,\n  style: styleFromProps,\n  tagName: Type = \"div\",\n  ...rest\n}) {\n  const context = useContext(PanelGroupContext);\n  if (context === null) {\n    throw Error(`Panel components must be rendered within a PanelGroup container`);\n  }\n  const {\n    collapsePanel,\n    expandPanel,\n    getPanelSize,\n    getPanelStyle,\n    groupId,\n    isPanelCollapsed,\n    reevaluatePanelConstraints,\n    registerPanel,\n    resizePanel,\n    unregisterPanel\n  } = context;\n  const panelId = useUniqueId(idFromProps);\n  const panelDataRef = useRef({\n    callbacks: {\n      onCollapse,\n      onExpand,\n      onResize\n    },\n    constraints: {\n      collapsedSize,\n      collapsible,\n      defaultSize,\n      maxSize,\n      minSize\n    },\n    id: panelId,\n    idIsFromProps: idFromProps !== undefined,\n    order\n  });\n  useRef({\n    didLogMissingDefaultSizeWarning: false\n  });\n  useIsomorphicLayoutEffect(() => {\n    const {\n      callbacks,\n      constraints\n    } = panelDataRef.current;\n    const prevConstraints = {\n      ...constraints\n    };\n    panelDataRef.current.id = panelId;\n    panelDataRef.current.idIsFromProps = idFromProps !== undefined;\n    panelDataRef.current.order = order;\n    callbacks.onCollapse = onCollapse;\n    callbacks.onExpand = onExpand;\n    callbacks.onResize = onResize;\n    constraints.collapsedSize = collapsedSize;\n    constraints.collapsible = collapsible;\n    constraints.defaultSize = defaultSize;\n    constraints.maxSize = maxSize;\n    constraints.minSize = minSize;\n\n    // If constraints have changed, we should revisit panel sizes.\n    // This is uncommon but may happen if people are trying to implement pixel based constraints.\n    if (prevConstraints.collapsedSize !== constraints.collapsedSize || prevConstraints.collapsible !== constraints.collapsible || prevConstraints.maxSize !== constraints.maxSize || prevConstraints.minSize !== constraints.minSize) {\n      reevaluatePanelConstraints(panelDataRef.current, prevConstraints);\n    }\n  });\n  useIsomorphicLayoutEffect(() => {\n    const panelData = panelDataRef.current;\n    registerPanel(panelData);\n    return () => {\n      unregisterPanel(panelData);\n    };\n  }, [order, panelId, registerPanel, unregisterPanel]);\n  useImperativeHandle(forwardedRef, () => ({\n    collapse: () => {\n      collapsePanel(panelDataRef.current);\n    },\n    expand: minSize => {\n      expandPanel(panelDataRef.current, minSize);\n    },\n    getId() {\n      return panelId;\n    },\n    getSize() {\n      return getPanelSize(panelDataRef.current);\n    },\n    isCollapsed() {\n      return isPanelCollapsed(panelDataRef.current);\n    },\n    isExpanded() {\n      return !isPanelCollapsed(panelDataRef.current);\n    },\n    resize: size => {\n      resizePanel(panelDataRef.current, size);\n    }\n  }), [collapsePanel, expandPanel, getPanelSize, isPanelCollapsed, panelId, resizePanel]);\n  const style = getPanelStyle(panelDataRef.current, defaultSize);\n  return createElement(Type, {\n    ...rest,\n    children,\n    className: classNameFromProps,\n    id: idFromProps,\n    style: {\n      ...style,\n      ...styleFromProps\n    },\n    // CSS selectors\n    \"data-panel\": \"\",\n    \"data-panel-collapsible\": collapsible || undefined,\n    \"data-panel-group-id\": groupId,\n    \"data-panel-id\": panelId,\n    \"data-panel-size\": parseFloat(\"\" + style.flexGrow).toFixed(1)\n  });\n}\nconst Panel = forwardRef((props, ref) => createElement(PanelWithForwardedRef, {\n  ...props,\n  forwardedRef: ref\n}));\nPanelWithForwardedRef.displayName = \"Panel\";\nPanel.displayName = \"forwardRef(Panel)\";\n\nlet nonce;\nfunction getNonce() {\n  return nonce;\n}\nfunction setNonce(value) {\n  nonce = value;\n}\n\nlet currentCursorStyle = null;\nlet enabled = true;\nlet styleElement = null;\nfunction disableGlobalCursorStyles() {\n  enabled = false;\n}\nfunction enableGlobalCursorStyles() {\n  enabled = true;\n}\nfunction getCursorStyle(state, constraintFlags) {\n  if (constraintFlags) {\n    const horizontalMin = (constraintFlags & EXCEEDED_HORIZONTAL_MIN) !== 0;\n    const horizontalMax = (constraintFlags & EXCEEDED_HORIZONTAL_MAX) !== 0;\n    const verticalMin = (constraintFlags & EXCEEDED_VERTICAL_MIN) !== 0;\n    const verticalMax = (constraintFlags & EXCEEDED_VERTICAL_MAX) !== 0;\n    if (horizontalMin) {\n      if (verticalMin) {\n        return \"se-resize\";\n      } else if (verticalMax) {\n        return \"ne-resize\";\n      } else {\n        return \"e-resize\";\n      }\n    } else if (horizontalMax) {\n      if (verticalMin) {\n        return \"sw-resize\";\n      } else if (verticalMax) {\n        return \"nw-resize\";\n      } else {\n        return \"w-resize\";\n      }\n    } else if (verticalMin) {\n      return \"s-resize\";\n    } else if (verticalMax) {\n      return \"n-resize\";\n    }\n  }\n  switch (state) {\n    case \"horizontal\":\n      return \"ew-resize\";\n    case \"intersection\":\n      return \"move\";\n    case \"vertical\":\n      return \"ns-resize\";\n  }\n}\nfunction resetGlobalCursorStyle() {\n  if (styleElement !== null) {\n    document.head.removeChild(styleElement);\n    currentCursorStyle = null;\n    styleElement = null;\n  }\n}\nfunction setGlobalCursorStyle(state, constraintFlags) {\n  if (!enabled) {\n    return;\n  }\n  const style = getCursorStyle(state, constraintFlags);\n  if (currentCursorStyle === style) {\n    return;\n  }\n  currentCursorStyle = style;\n  if (styleElement === null) {\n    styleElement = document.createElement(\"style\");\n    const nonce = getNonce();\n    if (nonce) {\n      styleElement.setAttribute(\"nonce\", nonce);\n    }\n    document.head.appendChild(styleElement);\n  }\n  styleElement.innerHTML = `*{cursor: ${style}!important;}`;\n}\n\nfunction isKeyDown(event) {\n  return event.type === \"keydown\";\n}\nfunction isPointerEvent(event) {\n  return event.type.startsWith(\"pointer\");\n}\nfunction isMouseEvent(event) {\n  return event.type.startsWith(\"mouse\");\n}\n\nfunction getResizeEventCoordinates(event) {\n  if (isPointerEvent(event)) {\n    if (event.isPrimary) {\n      return {\n        x: event.clientX,\n        y: event.clientY\n      };\n    }\n  } else if (isMouseEvent(event)) {\n    return {\n      x: event.clientX,\n      y: event.clientY\n    };\n  }\n  return {\n    x: Infinity,\n    y: Infinity\n  };\n}\n\nfunction getInputType() {\n  if (typeof matchMedia === \"function\") {\n    return matchMedia(\"(pointer:coarse)\").matches ? \"coarse\" : \"fine\";\n  }\n}\n\nfunction intersects(rectOne, rectTwo, strict) {\n  if (strict) {\n    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;\n  } else {\n    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;\n  }\n}\n\n// Forked from NPM stacking-order@2.0.0\n\n/**\n * Determine which of two nodes appears in front of the other —\n * if `a` is in front, returns 1, otherwise returns -1\n * @param {HTMLElement | SVGElement} a\n * @param {HTMLElement | SVGElement} b\n */\nfunction compare(a, b) {\n  if (a === b) throw new Error(\"Cannot compare node with itself\");\n  const ancestors = {\n    a: get_ancestors(a),\n    b: get_ancestors(b)\n  };\n  let common_ancestor;\n\n  // remove shared ancestors\n  while (ancestors.a.at(-1) === ancestors.b.at(-1)) {\n    a = ancestors.a.pop();\n    b = ancestors.b.pop();\n    common_ancestor = a;\n  }\n  assert(common_ancestor, \"Stacking order can only be calculated for elements with a common ancestor\");\n  const z_indexes = {\n    a: get_z_index(find_stacking_context(ancestors.a)),\n    b: get_z_index(find_stacking_context(ancestors.b))\n  };\n  if (z_indexes.a === z_indexes.b) {\n    const children = common_ancestor.childNodes;\n    const furthest_ancestors = {\n      a: ancestors.a.at(-1),\n      b: ancestors.b.at(-1)\n    };\n    let i = children.length;\n    while (i--) {\n      const child = children[i];\n      if (child === furthest_ancestors.a) return 1;\n      if (child === furthest_ancestors.b) return -1;\n    }\n  }\n  return Math.sign(z_indexes.a - z_indexes.b);\n}\nconst props = /\\b(?:position|zIndex|opacity|transform|webkitTransform|mixBlendMode|filter|webkitFilter|isolation)\\b/;\n\n/** @param {HTMLElement | SVGElement} node */\nfunction is_flex_item(node) {\n  var _get_parent;\n  // @ts-ignore\n  const display = getComputedStyle((_get_parent = get_parent(node)) !== null && _get_parent !== void 0 ? _get_parent : node).display;\n  return display === \"flex\" || display === \"inline-flex\";\n}\n\n/** @param {HTMLElement | SVGElement} node */\nfunction creates_stacking_context(node) {\n  const style = getComputedStyle(node);\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Positioning/Understanding_z_index/The_stacking_context\n  if (style.position === \"fixed\") return true;\n  // Forked to fix upstream bug https://github.com/Rich-Harris/stacking-order/issues/3\n  // if (\n  //   (style.zIndex !== \"auto\" && style.position !== \"static\") ||\n  //   is_flex_item(node)\n  // )\n  if (style.zIndex !== \"auto\" && (style.position !== \"static\" || is_flex_item(node))) return true;\n  if (+style.opacity < 1) return true;\n  if (\"transform\" in style && style.transform !== \"none\") return true;\n  if (\"webkitTransform\" in style && style.webkitTransform !== \"none\") return true;\n  if (\"mixBlendMode\" in style && style.mixBlendMode !== \"normal\") return true;\n  if (\"filter\" in style && style.filter !== \"none\") return true;\n  if (\"webkitFilter\" in style && style.webkitFilter !== \"none\") return true;\n  if (\"isolation\" in style && style.isolation === \"isolate\") return true;\n  if (props.test(style.willChange)) return true;\n  // @ts-expect-error\n  if (style.webkitOverflowScrolling === \"touch\") return true;\n  return false;\n}\n\n/** @param {(HTMLElement| SVGElement)[]} nodes */\nfunction find_stacking_context(nodes) {\n  let i = nodes.length;\n  while (i--) {\n    const node = nodes[i];\n    assert(node, \"Missing node\");\n    if (creates_stacking_context(node)) return node;\n  }\n  return null;\n}\n\n/** @param {HTMLElement | SVGElement} node */\nfunction get_z_index(node) {\n  return node && Number(getComputedStyle(node).zIndex) || 0;\n}\n\n/** @param {HTMLElement} node */\nfunction get_ancestors(node) {\n  const ancestors = [];\n  while (node) {\n    ancestors.push(node);\n    // @ts-ignore\n    node = get_parent(node);\n  }\n  return ancestors; // [ node, ... <body>, <html>, document ]\n}\n\n/** @param {HTMLElement} node */\nfunction get_parent(node) {\n  const {\n    parentNode\n  } = node;\n  if (parentNode && parentNode instanceof ShadowRoot) {\n    return parentNode.host;\n  }\n  return parentNode;\n}\n\nconst EXCEEDED_HORIZONTAL_MIN = 0b0001;\nconst EXCEEDED_HORIZONTAL_MAX = 0b0010;\nconst EXCEEDED_VERTICAL_MIN = 0b0100;\nconst EXCEEDED_VERTICAL_MAX = 0b1000;\nconst isCoarsePointer = getInputType() === \"coarse\";\nlet intersectingHandles = [];\nlet isPointerDown = false;\nlet ownerDocumentCounts = new Map();\nlet panelConstraintFlags = new Map();\nconst registeredResizeHandlers = new Set();\nfunction registerResizeHandle(resizeHandleId, element, direction, hitAreaMargins, setResizeHandlerState) {\n  var _ownerDocumentCounts$;\n  const {\n    ownerDocument\n  } = element;\n  const data = {\n    direction,\n    element,\n    hitAreaMargins,\n    setResizeHandlerState\n  };\n  const count = (_ownerDocumentCounts$ = ownerDocumentCounts.get(ownerDocument)) !== null && _ownerDocumentCounts$ !== void 0 ? _ownerDocumentCounts$ : 0;\n  ownerDocumentCounts.set(ownerDocument, count + 1);\n  registeredResizeHandlers.add(data);\n  updateListeners();\n  return function unregisterResizeHandle() {\n    var _ownerDocumentCounts$2;\n    panelConstraintFlags.delete(resizeHandleId);\n    registeredResizeHandlers.delete(data);\n    const count = (_ownerDocumentCounts$2 = ownerDocumentCounts.get(ownerDocument)) !== null && _ownerDocumentCounts$2 !== void 0 ? _ownerDocumentCounts$2 : 1;\n    ownerDocumentCounts.set(ownerDocument, count - 1);\n    updateListeners();\n    if (count === 1) {\n      ownerDocumentCounts.delete(ownerDocument);\n    }\n\n    // If the resize handle that is currently unmounting is intersecting with the pointer,\n    // update the global pointer to account for the change\n    if (intersectingHandles.includes(data)) {\n      const index = intersectingHandles.indexOf(data);\n      if (index >= 0) {\n        intersectingHandles.splice(index, 1);\n      }\n      updateCursor();\n\n      // Also instruct the handle to stop dragging; this prevents the parent group from being left in an inconsistent state\n      // See github.com/bvaughn/react-resizable-panels/issues/402\n      setResizeHandlerState(\"up\", true, null);\n    }\n  };\n}\nfunction handlePointerDown(event) {\n  const {\n    target\n  } = event;\n  const {\n    x,\n    y\n  } = getResizeEventCoordinates(event);\n  isPointerDown = true;\n  recalculateIntersectingHandles({\n    target,\n    x,\n    y\n  });\n  updateListeners();\n  if (intersectingHandles.length > 0) {\n    updateResizeHandlerStates(\"down\", event);\n    event.preventDefault();\n    event.stopPropagation();\n  }\n}\nfunction handlePointerMove(event) {\n  const {\n    x,\n    y\n  } = getResizeEventCoordinates(event);\n\n  // Edge case (see #340)\n  // Detect when the pointer has been released outside an iframe on a different domain\n  if (isPointerDown && event.buttons === 0) {\n    isPointerDown = false;\n    updateResizeHandlerStates(\"up\", event);\n  }\n  if (!isPointerDown) {\n    const {\n      target\n    } = event;\n\n    // Recalculate intersecting handles whenever the pointer moves, except if it has already been pressed\n    // at that point, the handles may not move with the pointer (depending on constraints)\n    // but the same set of active handles should be locked until the pointer is released\n    recalculateIntersectingHandles({\n      target,\n      x,\n      y\n    });\n  }\n  updateResizeHandlerStates(\"move\", event);\n\n  // Update cursor based on return value(s) from active handles\n  updateCursor();\n  if (intersectingHandles.length > 0) {\n    event.preventDefault();\n  }\n}\nfunction handlePointerUp(event) {\n  const {\n    target\n  } = event;\n  const {\n    x,\n    y\n  } = getResizeEventCoordinates(event);\n  panelConstraintFlags.clear();\n  isPointerDown = false;\n  if (intersectingHandles.length > 0) {\n    event.preventDefault();\n  }\n  updateResizeHandlerStates(\"up\", event);\n  recalculateIntersectingHandles({\n    target,\n    x,\n    y\n  });\n  updateCursor();\n  updateListeners();\n}\nfunction recalculateIntersectingHandles({\n  target,\n  x,\n  y\n}) {\n  intersectingHandles.splice(0);\n  let targetElement = null;\n  if (target instanceof HTMLElement || target instanceof SVGElement) {\n    targetElement = target;\n  }\n  registeredResizeHandlers.forEach(data => {\n    const {\n      element: dragHandleElement,\n      hitAreaMargins\n    } = data;\n    const dragHandleRect = dragHandleElement.getBoundingClientRect();\n    const {\n      bottom,\n      left,\n      right,\n      top\n    } = dragHandleRect;\n    const margin = isCoarsePointer ? hitAreaMargins.coarse : hitAreaMargins.fine;\n    const eventIntersects = x >= left - margin && x <= right + margin && y >= top - margin && y <= bottom + margin;\n    if (eventIntersects) {\n      // TRICKY\n      // We listen for pointers events at the root in order to support hit area margins\n      // (determining when the pointer is close enough to an element to be considered a \"hit\")\n      // Clicking on an element \"above\" a handle (e.g. a modal) should prevent a hit though\n      // so at this point we need to compare stacking order of a potentially intersecting drag handle,\n      // and the element that was actually clicked/touched\n      if (targetElement !== null && document.contains(targetElement) && dragHandleElement !== targetElement && !dragHandleElement.contains(targetElement) && !targetElement.contains(dragHandleElement) &&\n      // Calculating stacking order has a cost, so we should avoid it if possible\n      // That is why we only check potentially intersecting handles,\n      // and why we skip if the event target is within the handle's DOM\n      compare(targetElement, dragHandleElement) > 0) {\n        // If the target is above the drag handle, then we also need to confirm they overlap\n        // If they are beside each other (e.g. a panel and its drag handle) then the handle is still interactive\n        //\n        // It's not enough to compare only the target\n        // The target might be a small element inside of a larger container\n        // (For example, a SPAN or a DIV inside of a larger modal dialog)\n        let currentElement = targetElement;\n        let didIntersect = false;\n        while (currentElement) {\n          if (currentElement.contains(dragHandleElement)) {\n            break;\n          } else if (intersects(currentElement.getBoundingClientRect(), dragHandleRect, true)) {\n            didIntersect = true;\n            break;\n          }\n          currentElement = currentElement.parentElement;\n        }\n        if (didIntersect) {\n          return;\n        }\n      }\n      intersectingHandles.push(data);\n    }\n  });\n}\nfunction reportConstraintsViolation(resizeHandleId, flag) {\n  panelConstraintFlags.set(resizeHandleId, flag);\n}\nfunction updateCursor() {\n  let intersectsHorizontal = false;\n  let intersectsVertical = false;\n  intersectingHandles.forEach(data => {\n    const {\n      direction\n    } = data;\n    if (direction === \"horizontal\") {\n      intersectsHorizontal = true;\n    } else {\n      intersectsVertical = true;\n    }\n  });\n  let constraintFlags = 0;\n  panelConstraintFlags.forEach(flag => {\n    constraintFlags |= flag;\n  });\n  if (intersectsHorizontal && intersectsVertical) {\n    setGlobalCursorStyle(\"intersection\", constraintFlags);\n  } else if (intersectsHorizontal) {\n    setGlobalCursorStyle(\"horizontal\", constraintFlags);\n  } else if (intersectsVertical) {\n    setGlobalCursorStyle(\"vertical\", constraintFlags);\n  } else {\n    resetGlobalCursorStyle();\n  }\n}\nfunction updateListeners() {\n  ownerDocumentCounts.forEach((_, ownerDocument) => {\n    const {\n      body\n    } = ownerDocument;\n    body.removeEventListener(\"contextmenu\", handlePointerUp);\n    body.removeEventListener(\"pointerdown\", handlePointerDown);\n    body.removeEventListener(\"pointerleave\", handlePointerMove);\n    body.removeEventListener(\"pointermove\", handlePointerMove);\n  });\n  window.removeEventListener(\"pointerup\", handlePointerUp);\n  window.removeEventListener(\"pointercancel\", handlePointerUp);\n  if (registeredResizeHandlers.size > 0) {\n    if (isPointerDown) {\n      if (intersectingHandles.length > 0) {\n        ownerDocumentCounts.forEach((count, ownerDocument) => {\n          const {\n            body\n          } = ownerDocument;\n          if (count > 0) {\n            body.addEventListener(\"contextmenu\", handlePointerUp);\n            body.addEventListener(\"pointerleave\", handlePointerMove);\n            body.addEventListener(\"pointermove\", handlePointerMove);\n          }\n        });\n      }\n      window.addEventListener(\"pointerup\", handlePointerUp);\n      window.addEventListener(\"pointercancel\", handlePointerUp);\n    } else {\n      ownerDocumentCounts.forEach((count, ownerDocument) => {\n        const {\n          body\n        } = ownerDocument;\n        if (count > 0) {\n          body.addEventListener(\"pointerdown\", handlePointerDown, {\n            capture: true\n          });\n          body.addEventListener(\"pointermove\", handlePointerMove);\n        }\n      });\n    }\n  }\n}\nfunction updateResizeHandlerStates(action, event) {\n  registeredResizeHandlers.forEach(data => {\n    const {\n      setResizeHandlerState\n    } = data;\n    const isActive = intersectingHandles.includes(data);\n    setResizeHandlerState(action, isActive, event);\n  });\n}\n\nfunction useForceUpdate() {\n  const [_, setCount] = useState(0);\n  return useCallback(() => setCount(prevCount => prevCount + 1), []);\n}\n\nfunction assert(expectedCondition, message) {\n  if (!expectedCondition) {\n    console.error(message);\n    throw Error(message);\n  }\n}\n\nconst PRECISION = 10;\n\nfunction fuzzyCompareNumbers(actual, expected, fractionDigits = PRECISION) {\n  if (actual.toFixed(fractionDigits) === expected.toFixed(fractionDigits)) {\n    return 0;\n  } else {\n    return actual > expected ? 1 : -1;\n  }\n}\nfunction fuzzyNumbersEqual$1(actual, expected, fractionDigits = PRECISION) {\n  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;\n}\n\nfunction fuzzyNumbersEqual(actual, expected, fractionDigits) {\n  return fuzzyCompareNumbers(actual, expected, fractionDigits) === 0;\n}\n\nfunction fuzzyLayoutsEqual(actual, expected, fractionDigits) {\n  if (actual.length !== expected.length) {\n    return false;\n  }\n  for (let index = 0; index < actual.length; index++) {\n    const actualSize = actual[index];\n    const expectedSize = expected[index];\n    if (!fuzzyNumbersEqual(actualSize, expectedSize, fractionDigits)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// Panel size must be in percentages; pixel values should be pre-converted\nfunction resizePanel({\n  panelConstraints: panelConstraintsArray,\n  panelIndex,\n  size\n}) {\n  const panelConstraints = panelConstraintsArray[panelIndex];\n  assert(panelConstraints != null, `Panel constraints not found for index ${panelIndex}`);\n  let {\n    collapsedSize = 0,\n    collapsible,\n    maxSize = 100,\n    minSize = 0\n  } = panelConstraints;\n  if (fuzzyCompareNumbers(size, minSize) < 0) {\n    if (collapsible) {\n      // Collapsible panels should snap closed or open only once they cross the halfway point between collapsed and min size.\n      const halfwayPoint = (collapsedSize + minSize) / 2;\n      if (fuzzyCompareNumbers(size, halfwayPoint) < 0) {\n        size = collapsedSize;\n      } else {\n        size = minSize;\n      }\n    } else {\n      size = minSize;\n    }\n  }\n  size = Math.min(maxSize, size);\n  size = parseFloat(size.toFixed(PRECISION));\n  return size;\n}\n\n// All units must be in percentages; pixel values should be pre-converted\nfunction adjustLayoutByDelta({\n  delta,\n  initialLayout,\n  panelConstraints: panelConstraintsArray,\n  pivotIndices,\n  prevLayout,\n  trigger\n}) {\n  if (fuzzyNumbersEqual(delta, 0)) {\n    return initialLayout;\n  }\n  const nextLayout = [...initialLayout];\n  const [firstPivotIndex, secondPivotIndex] = pivotIndices;\n  assert(firstPivotIndex != null, \"Invalid first pivot index\");\n  assert(secondPivotIndex != null, \"Invalid second pivot index\");\n  let deltaApplied = 0;\n\n  // const DEBUG = [];\n  // DEBUG.push(`adjustLayoutByDelta()`);\n  // DEBUG.push(`  initialLayout: ${initialLayout.join(\", \")}`);\n  // DEBUG.push(`  prevLayout: ${prevLayout.join(\", \")}`);\n  // DEBUG.push(`  delta: ${delta}`);\n  // DEBUG.push(`  pivotIndices: ${pivotIndices.join(\", \")}`);\n  // DEBUG.push(`  trigger: ${trigger}`);\n  // DEBUG.push(\"\");\n\n  // A resizing panel affects the panels before or after it.\n  //\n  // A negative delta means the panel(s) immediately after the resize handle should grow/expand by decreasing its offset.\n  // Other panels may also need to shrink/contract (and shift) to make room, depending on the min weights.\n  //\n  // A positive delta means the panel(s) immediately before the resize handle should \"expand\".\n  // This is accomplished by shrinking/contracting (and shifting) one or more of the panels after the resize handle.\n\n  {\n    // If this is a resize triggered by a keyboard event, our logic for expanding/collapsing is different.\n    // We no longer check the halfway threshold because this may prevent the panel from expanding at all.\n    if (trigger === \"keyboard\") {\n      {\n        // Check if we should expand a collapsed panel\n        const index = delta < 0 ? secondPivotIndex : firstPivotIndex;\n        const panelConstraints = panelConstraintsArray[index];\n        assert(panelConstraints, `Panel constraints not found for index ${index}`);\n        const {\n          collapsedSize = 0,\n          collapsible,\n          minSize = 0\n        } = panelConstraints;\n\n        // DEBUG.push(`edge case check 1: ${index}`);\n        // DEBUG.push(`  -> collapsible? ${collapsible}`);\n        if (collapsible) {\n          const prevSize = initialLayout[index];\n          assert(prevSize != null, `Previous layout not found for panel index ${index}`);\n          if (fuzzyNumbersEqual(prevSize, collapsedSize)) {\n            const localDelta = minSize - prevSize;\n            // DEBUG.push(`  -> expand delta: ${localDelta}`);\n\n            if (fuzzyCompareNumbers(localDelta, Math.abs(delta)) > 0) {\n              delta = delta < 0 ? 0 - localDelta : localDelta;\n              // DEBUG.push(`  -> delta: ${delta}`);\n            }\n          }\n        }\n      }\n\n      {\n        // Check if we should collapse a panel at its minimum size\n        const index = delta < 0 ? firstPivotIndex : secondPivotIndex;\n        const panelConstraints = panelConstraintsArray[index];\n        assert(panelConstraints, `No panel constraints found for index ${index}`);\n        const {\n          collapsedSize = 0,\n          collapsible,\n          minSize = 0\n        } = panelConstraints;\n\n        // DEBUG.push(`edge case check 2: ${index}`);\n        // DEBUG.push(`  -> collapsible? ${collapsible}`);\n        if (collapsible) {\n          const prevSize = initialLayout[index];\n          assert(prevSize != null, `Previous layout not found for panel index ${index}`);\n          if (fuzzyNumbersEqual(prevSize, minSize)) {\n            const localDelta = prevSize - collapsedSize;\n            // DEBUG.push(`  -> expand delta: ${localDelta}`);\n\n            if (fuzzyCompareNumbers(localDelta, Math.abs(delta)) > 0) {\n              delta = delta < 0 ? 0 - localDelta : localDelta;\n              // DEBUG.push(`  -> delta: ${delta}`);\n            }\n          }\n        }\n      }\n    }\n    // DEBUG.push(\"\");\n  }\n\n  {\n    // Pre-calculate max available delta in the opposite direction of our pivot.\n    // This will be the maximum amount we're allowed to expand/contract the panels in the primary direction.\n    // If this amount is less than the requested delta, adjust the requested delta.\n    // If this amount is greater than the requested delta, that's useful information too–\n    // as an expanding panel might change from collapsed to min size.\n\n    const increment = delta < 0 ? 1 : -1;\n    let index = delta < 0 ? secondPivotIndex : firstPivotIndex;\n    let maxAvailableDelta = 0;\n\n    // DEBUG.push(\"pre calc...\");\n    while (true) {\n      const prevSize = initialLayout[index];\n      assert(prevSize != null, `Previous layout not found for panel index ${index}`);\n      const maxSafeSize = resizePanel({\n        panelConstraints: panelConstraintsArray,\n        panelIndex: index,\n        size: 100\n      });\n      const delta = maxSafeSize - prevSize;\n      // DEBUG.push(`  ${index}: ${prevSize} -> ${maxSafeSize}`);\n\n      maxAvailableDelta += delta;\n      index += increment;\n      if (index < 0 || index >= panelConstraintsArray.length) {\n        break;\n      }\n    }\n\n    // DEBUG.push(`  -> max available delta: ${maxAvailableDelta}`);\n    const minAbsDelta = Math.min(Math.abs(delta), Math.abs(maxAvailableDelta));\n    delta = delta < 0 ? 0 - minAbsDelta : minAbsDelta;\n    // DEBUG.push(`  -> adjusted delta: ${delta}`);\n    // DEBUG.push(\"\");\n  }\n\n  {\n    // Delta added to a panel needs to be subtracted from other panels (within the constraints that those panels allow).\n\n    const pivotIndex = delta < 0 ? firstPivotIndex : secondPivotIndex;\n    let index = pivotIndex;\n    while (index >= 0 && index < panelConstraintsArray.length) {\n      const deltaRemaining = Math.abs(delta) - Math.abs(deltaApplied);\n      const prevSize = initialLayout[index];\n      assert(prevSize != null, `Previous layout not found for panel index ${index}`);\n      const unsafeSize = prevSize - deltaRemaining;\n      const safeSize = resizePanel({\n        panelConstraints: panelConstraintsArray,\n        panelIndex: index,\n        size: unsafeSize\n      });\n      if (!fuzzyNumbersEqual(prevSize, safeSize)) {\n        deltaApplied += prevSize - safeSize;\n        nextLayout[index] = safeSize;\n        if (deltaApplied.toPrecision(3).localeCompare(Math.abs(delta).toPrecision(3), undefined, {\n          numeric: true\n        }) >= 0) {\n          break;\n        }\n      }\n      if (delta < 0) {\n        index--;\n      } else {\n        index++;\n      }\n    }\n  }\n  // DEBUG.push(`after 1: ${nextLayout.join(\", \")}`);\n  // DEBUG.push(`  deltaApplied: ${deltaApplied}`);\n  // DEBUG.push(\"\");\n\n  // If we were unable to resize any of the panels panels, return the previous state.\n  // This will essentially bailout and ignore e.g. drags past a panel's boundaries\n  if (fuzzyLayoutsEqual(prevLayout, nextLayout)) {\n    // DEBUG.push(`bailout to previous layout: ${prevLayout.join(\", \")}`);\n    // console.log(DEBUG.join(\"\\n\"));\n\n    return prevLayout;\n  }\n  {\n    // Now distribute the applied delta to the panels in the other direction\n    const pivotIndex = delta < 0 ? secondPivotIndex : firstPivotIndex;\n    const prevSize = initialLayout[pivotIndex];\n    assert(prevSize != null, `Previous layout not found for panel index ${pivotIndex}`);\n    const unsafeSize = prevSize + deltaApplied;\n    const safeSize = resizePanel({\n      panelConstraints: panelConstraintsArray,\n      panelIndex: pivotIndex,\n      size: unsafeSize\n    });\n\n    // Adjust the pivot panel before, but only by the amount that surrounding panels were able to shrink/contract.\n    nextLayout[pivotIndex] = safeSize;\n\n    // Edge case where expanding or contracting one panel caused another one to change collapsed state\n    if (!fuzzyNumbersEqual(safeSize, unsafeSize)) {\n      let deltaRemaining = unsafeSize - safeSize;\n      const pivotIndex = delta < 0 ? secondPivotIndex : firstPivotIndex;\n      let index = pivotIndex;\n      while (index >= 0 && index < panelConstraintsArray.length) {\n        const prevSize = nextLayout[index];\n        assert(prevSize != null, `Previous layout not found for panel index ${index}`);\n        const unsafeSize = prevSize + deltaRemaining;\n        const safeSize = resizePanel({\n          panelConstraints: panelConstraintsArray,\n          panelIndex: index,\n          size: unsafeSize\n        });\n        if (!fuzzyNumbersEqual(prevSize, safeSize)) {\n          deltaRemaining -= safeSize - prevSize;\n          nextLayout[index] = safeSize;\n        }\n        if (fuzzyNumbersEqual(deltaRemaining, 0)) {\n          break;\n        }\n        if (delta > 0) {\n          index--;\n        } else {\n          index++;\n        }\n      }\n    }\n  }\n  // DEBUG.push(`after 2: ${nextLayout.join(\", \")}`);\n  // DEBUG.push(`  deltaApplied: ${deltaApplied}`);\n  // DEBUG.push(\"\");\n\n  const totalSize = nextLayout.reduce((total, size) => size + total, 0);\n  // DEBUG.push(`total size: ${totalSize}`);\n\n  // If our new layout doesn't add up to 100%, that means the requested delta can't be applied\n  // In that case, fall back to our most recent valid layout\n  if (!fuzzyNumbersEqual(totalSize, 100)) {\n    // DEBUG.push(`bailout to previous layout: ${prevLayout.join(\", \")}`);\n    // console.log(DEBUG.join(\"\\n\"));\n\n    return prevLayout;\n  }\n\n  // console.log(DEBUG.join(\"\\n\"));\n  return nextLayout;\n}\n\nfunction calculateAriaValues({\n  layout,\n  panelsArray,\n  pivotIndices\n}) {\n  let currentMinSize = 0;\n  let currentMaxSize = 100;\n  let totalMinSize = 0;\n  let totalMaxSize = 0;\n  const firstIndex = pivotIndices[0];\n  assert(firstIndex != null, \"No pivot index found\");\n\n  // A panel's effective min/max sizes also need to account for other panel's sizes.\n  panelsArray.forEach((panelData, index) => {\n    const {\n      constraints\n    } = panelData;\n    const {\n      maxSize = 100,\n      minSize = 0\n    } = constraints;\n    if (index === firstIndex) {\n      currentMinSize = minSize;\n      currentMaxSize = maxSize;\n    } else {\n      totalMinSize += minSize;\n      totalMaxSize += maxSize;\n    }\n  });\n  const valueMax = Math.min(currentMaxSize, 100 - totalMinSize);\n  const valueMin = Math.max(currentMinSize, 100 - totalMaxSize);\n  const valueNow = layout[firstIndex];\n  return {\n    valueMax,\n    valueMin,\n    valueNow\n  };\n}\n\nfunction getResizeHandleElementsForGroup(groupId, scope = document) {\n  return Array.from(scope.querySelectorAll(`[data-panel-resize-handle-id][data-panel-group-id=\"${groupId}\"]`));\n}\n\nfunction getResizeHandleElementIndex(groupId, id, scope = document) {\n  const handles = getResizeHandleElementsForGroup(groupId, scope);\n  const index = handles.findIndex(handle => handle.getAttribute(\"data-panel-resize-handle-id\") === id);\n  return index !== null && index !== void 0 ? index : null;\n}\n\nfunction determinePivotIndices(groupId, dragHandleId, panelGroupElement) {\n  const index = getResizeHandleElementIndex(groupId, dragHandleId, panelGroupElement);\n  return index != null ? [index, index + 1] : [-1, -1];\n}\n\nfunction getPanelGroupElement(id, rootElement = document) {\n  var _dataset;\n  //If the root element is the PanelGroup\n  if (rootElement instanceof HTMLElement && (rootElement === null || rootElement === void 0 ? void 0 : (_dataset = rootElement.dataset) === null || _dataset === void 0 ? void 0 : _dataset.panelGroupId) == id) {\n    return rootElement;\n  }\n\n  //Else query children\n  const element = rootElement.querySelector(`[data-panel-group][data-panel-group-id=\"${id}\"]`);\n  if (element) {\n    return element;\n  }\n  return null;\n}\n\nfunction getResizeHandleElement(id, scope = document) {\n  const element = scope.querySelector(`[data-panel-resize-handle-id=\"${id}\"]`);\n  if (element) {\n    return element;\n  }\n  return null;\n}\n\nfunction getResizeHandlePanelIds(groupId, handleId, panelsArray, scope = document) {\n  var _panelsArray$index$id, _panelsArray$index, _panelsArray$id, _panelsArray;\n  const handle = getResizeHandleElement(handleId, scope);\n  const handles = getResizeHandleElementsForGroup(groupId, scope);\n  const index = handle ? handles.indexOf(handle) : -1;\n  const 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;\n  const idAfter = (_panelsArray$id = (_panelsArray = panelsArray[index + 1]) === null || _panelsArray === void 0 ? void 0 : _panelsArray.id) !== null && _panelsArray$id !== void 0 ? _panelsArray$id : null;\n  return [idBefore, idAfter];\n}\n\n// https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/\n\nfunction useWindowSplitterPanelGroupBehavior({\n  committedValuesRef,\n  eagerValuesRef,\n  groupId,\n  layout,\n  panelDataArray,\n  panelGroupElement,\n  setLayout\n}) {\n  useRef({\n    didWarnAboutMissingResizeHandle: false\n  });\n  useIsomorphicLayoutEffect(() => {\n    if (!panelGroupElement) {\n      return;\n    }\n    const resizeHandleElements = getResizeHandleElementsForGroup(groupId, panelGroupElement);\n    for (let index = 0; index < panelDataArray.length - 1; index++) {\n      const {\n        valueMax,\n        valueMin,\n        valueNow\n      } = calculateAriaValues({\n        layout,\n        panelsArray: panelDataArray,\n        pivotIndices: [index, index + 1]\n      });\n      const resizeHandleElement = resizeHandleElements[index];\n      if (resizeHandleElement == null) ; else {\n        const panelData = panelDataArray[index];\n        assert(panelData, `No panel data found for index \"${index}\"`);\n        resizeHandleElement.setAttribute(\"aria-controls\", panelData.id);\n        resizeHandleElement.setAttribute(\"aria-valuemax\", \"\" + Math.round(valueMax));\n        resizeHandleElement.setAttribute(\"aria-valuemin\", \"\" + Math.round(valueMin));\n        resizeHandleElement.setAttribute(\"aria-valuenow\", valueNow != null ? \"\" + Math.round(valueNow) : \"\");\n      }\n    }\n    return () => {\n      resizeHandleElements.forEach((resizeHandleElement, index) => {\n        resizeHandleElement.removeAttribute(\"aria-controls\");\n        resizeHandleElement.removeAttribute(\"aria-valuemax\");\n        resizeHandleElement.removeAttribute(\"aria-valuemin\");\n        resizeHandleElement.removeAttribute(\"aria-valuenow\");\n      });\n    };\n  }, [groupId, layout, panelDataArray, panelGroupElement]);\n  useEffect(() => {\n    if (!panelGroupElement) {\n      return;\n    }\n    const eagerValues = eagerValuesRef.current;\n    assert(eagerValues, `Eager values not found`);\n    const {\n      panelDataArray\n    } = eagerValues;\n    const groupElement = getPanelGroupElement(groupId, panelGroupElement);\n    assert(groupElement != null, `No group found for id \"${groupId}\"`);\n    const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement);\n    assert(handles, `No resize handles found for group id \"${groupId}\"`);\n    const cleanupFunctions = handles.map(handle => {\n      const handleId = handle.getAttribute(\"data-panel-resize-handle-id\");\n      assert(handleId, `Resize handle element has no handle id attribute`);\n      const [idBefore, idAfter] = getResizeHandlePanelIds(groupId, handleId, panelDataArray, panelGroupElement);\n      if (idBefore == null || idAfter == null) {\n        return () => {};\n      }\n      const onKeyDown = event => {\n        if (event.defaultPrevented) {\n          return;\n        }\n        switch (event.key) {\n          case \"Enter\":\n            {\n              event.preventDefault();\n              const index = panelDataArray.findIndex(panelData => panelData.id === idBefore);\n              if (index >= 0) {\n                const panelData = panelDataArray[index];\n                assert(panelData, `No panel data found for index ${index}`);\n                const size = layout[index];\n                const {\n                  collapsedSize = 0,\n                  collapsible,\n                  minSize = 0\n                } = panelData.constraints;\n                if (size != null && collapsible) {\n                  const nextLayout = adjustLayoutByDelta({\n                    delta: fuzzyNumbersEqual(size, collapsedSize) ? minSize - collapsedSize : collapsedSize - size,\n                    initialLayout: layout,\n                    panelConstraints: panelDataArray.map(panelData => panelData.constraints),\n                    pivotIndices: determinePivotIndices(groupId, handleId, panelGroupElement),\n                    prevLayout: layout,\n                    trigger: \"keyboard\"\n                  });\n                  if (layout !== nextLayout) {\n                    setLayout(nextLayout);\n                  }\n                }\n              }\n              break;\n            }\n        }\n      };\n      handle.addEventListener(\"keydown\", onKeyDown);\n      return () => {\n        handle.removeEventListener(\"keydown\", onKeyDown);\n      };\n    });\n    return () => {\n      cleanupFunctions.forEach(cleanupFunction => cleanupFunction());\n    };\n  }, [panelGroupElement, committedValuesRef, eagerValuesRef, groupId, layout, panelDataArray, setLayout]);\n}\n\nfunction areEqual(arrayA, arrayB) {\n  if (arrayA.length !== arrayB.length) {\n    return false;\n  }\n  for (let index = 0; index < arrayA.length; index++) {\n    if (arrayA[index] !== arrayB[index]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction getResizeEventCursorPosition(direction, event) {\n  const isHorizontal = direction === \"horizontal\";\n  const {\n    x,\n    y\n  } = getResizeEventCoordinates(event);\n  return isHorizontal ? x : y;\n}\n\nfunction calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement) {\n  const isHorizontal = direction === \"horizontal\";\n  const handleElement = getResizeHandleElement(dragHandleId, panelGroupElement);\n  assert(handleElement, `No resize handle element found for id \"${dragHandleId}\"`);\n  const groupId = handleElement.getAttribute(\"data-panel-group-id\");\n  assert(groupId, `Resize handle element has no group id attribute`);\n  let {\n    initialCursorPosition\n  } = initialDragState;\n  const cursorPosition = getResizeEventCursorPosition(direction, event);\n  const groupElement = getPanelGroupElement(groupId, panelGroupElement);\n  assert(groupElement, `No group element found for id \"${groupId}\"`);\n  const groupRect = groupElement.getBoundingClientRect();\n  const groupSizeInPixels = isHorizontal ? groupRect.width : groupRect.height;\n  const offsetPixels = cursorPosition - initialCursorPosition;\n  const offsetPercentage = offsetPixels / groupSizeInPixels * 100;\n  return offsetPercentage;\n}\n\n// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/movementX\nfunction calculateDeltaPercentage(event, dragHandleId, direction, initialDragState, keyboardResizeBy, panelGroupElement) {\n  if (isKeyDown(event)) {\n    const isHorizontal = direction === \"horizontal\";\n    let delta = 0;\n    if (event.shiftKey) {\n      delta = 100;\n    } else if (keyboardResizeBy != null) {\n      delta = keyboardResizeBy;\n    } else {\n      delta = 10;\n    }\n    let movement = 0;\n    switch (event.key) {\n      case \"ArrowDown\":\n        movement = isHorizontal ? 0 : delta;\n        break;\n      case \"ArrowLeft\":\n        movement = isHorizontal ? -delta : 0;\n        break;\n      case \"ArrowRight\":\n        movement = isHorizontal ? delta : 0;\n        break;\n      case \"ArrowUp\":\n        movement = isHorizontal ? 0 : -delta;\n        break;\n      case \"End\":\n        movement = 100;\n        break;\n      case \"Home\":\n        movement = -100;\n        break;\n    }\n    return movement;\n  } else {\n    if (initialDragState == null) {\n      return 0;\n    }\n    return calculateDragOffsetPercentage(event, dragHandleId, direction, initialDragState, panelGroupElement);\n  }\n}\n\nfunction calculateUnsafeDefaultLayout({\n  panelDataArray\n}) {\n  const layout = Array(panelDataArray.length);\n  const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);\n  let numPanelsWithSizes = 0;\n  let remainingSize = 100;\n\n  // Distribute default sizes first\n  for (let index = 0; index < panelDataArray.length; index++) {\n    const panelConstraints = panelConstraintsArray[index];\n    assert(panelConstraints, `Panel constraints not found for index ${index}`);\n    const {\n      defaultSize\n    } = panelConstraints;\n    if (defaultSize != null) {\n      numPanelsWithSizes++;\n      layout[index] = defaultSize;\n      remainingSize -= defaultSize;\n    }\n  }\n\n  // Remaining size should be distributed evenly between panels without default sizes\n  for (let index = 0; index < panelDataArray.length; index++) {\n    const panelConstraints = panelConstraintsArray[index];\n    assert(panelConstraints, `Panel constraints not found for index ${index}`);\n    const {\n      defaultSize\n    } = panelConstraints;\n    if (defaultSize != null) {\n      continue;\n    }\n    const numRemainingPanels = panelDataArray.length - numPanelsWithSizes;\n    const size = remainingSize / numRemainingPanels;\n    numPanelsWithSizes++;\n    layout[index] = size;\n    remainingSize -= size;\n  }\n  return layout;\n}\n\n// Layout should be pre-converted into percentages\nfunction callPanelCallbacks(panelsArray, layout, panelIdToLastNotifiedSizeMap) {\n  layout.forEach((size, index) => {\n    const panelData = panelsArray[index];\n    assert(panelData, `Panel data not found for index ${index}`);\n    const {\n      callbacks,\n      constraints,\n      id: panelId\n    } = panelData;\n    const {\n      collapsedSize = 0,\n      collapsible\n    } = constraints;\n    const lastNotifiedSize = panelIdToLastNotifiedSizeMap[panelId];\n    if (lastNotifiedSize == null || size !== lastNotifiedSize) {\n      panelIdToLastNotifiedSizeMap[panelId] = size;\n      const {\n        onCollapse,\n        onExpand,\n        onResize\n      } = callbacks;\n      if (onResize) {\n        onResize(size, lastNotifiedSize);\n      }\n      if (collapsible && (onCollapse || onExpand)) {\n        if (onExpand && (lastNotifiedSize == null || fuzzyNumbersEqual$1(lastNotifiedSize, collapsedSize)) && !fuzzyNumbersEqual$1(size, collapsedSize)) {\n          onExpand();\n        }\n        if (onCollapse && (lastNotifiedSize == null || !fuzzyNumbersEqual$1(lastNotifiedSize, collapsedSize)) && fuzzyNumbersEqual$1(size, collapsedSize)) {\n          onCollapse();\n        }\n      }\n    }\n  });\n}\n\nfunction compareLayouts(a, b) {\n  if (a.length !== b.length) {\n    return false;\n  } else {\n    for (let index = 0; index < a.length; index++) {\n      if (a[index] != b[index]) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\n// This method returns a number between 1 and 100 representing\n\n// the % of the group's overall space this panel should occupy.\nfunction computePanelFlexBoxStyle({\n  defaultSize,\n  dragState,\n  layout,\n  panelData,\n  panelIndex,\n  precision = 3\n}) {\n  const size = layout[panelIndex];\n  let flexGrow;\n  if (size == null) {\n    // Initial render (before panels have registered themselves)\n    // In order to support server rendering, fall back to default size if provided\n    flexGrow = defaultSize != undefined ? defaultSize.toPrecision(precision) : \"1\";\n  } else if (panelData.length === 1) {\n    // Special case: Single panel group should always fill full width/height\n    flexGrow = \"1\";\n  } else {\n    flexGrow = size.toPrecision(precision);\n  }\n  return {\n    flexBasis: 0,\n    flexGrow,\n    flexShrink: 1,\n    // Without this, Panel sizes may be unintentionally overridden by their content\n    overflow: \"hidden\",\n    // Disable pointer events inside of a panel during resize\n    // This avoid edge cases like nested iframes\n    pointerEvents: dragState !== null ? \"none\" : undefined\n  };\n}\n\nfunction debounce(callback, durationMs = 10) {\n  let timeoutId = null;\n  let callable = (...args) => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n    timeoutId = setTimeout(() => {\n      callback(...args);\n    }, durationMs);\n  };\n  return callable;\n}\n\n// PanelGroup might be rendering in a server-side environment where localStorage is not available\n// or on a browser with cookies/storage disabled.\n// In either case, this function avoids accessing localStorage until needed,\n// and avoids throwing user-visible errors.\nfunction initializeDefaultStorage(storageObject) {\n  try {\n    if (typeof localStorage !== \"undefined\") {\n      // Bypass this check for future calls\n      storageObject.getItem = name => {\n        return localStorage.getItem(name);\n      };\n      storageObject.setItem = (name, value) => {\n        localStorage.setItem(name, value);\n      };\n    } else {\n      throw new Error(\"localStorage not supported in this environment\");\n    }\n  } catch (error) {\n    console.error(error);\n    storageObject.getItem = () => null;\n    storageObject.setItem = () => {};\n  }\n}\n\nfunction getPanelGroupKey(autoSaveId) {\n  return `react-resizable-panels:${autoSaveId}`;\n}\n\n// Note that Panel ids might be user-provided (stable) or useId generated (non-deterministic)\n// so they should not be used as part of the serialization key.\n// Using the min/max size attributes should work well enough as a backup.\n// Pre-sorting by minSize allows remembering layouts even if panels are re-ordered/dragged.\nfunction getPanelKey(panels) {\n  return panels.map(panel => {\n    const {\n      constraints,\n      id,\n      idIsFromProps,\n      order\n    } = panel;\n    if (idIsFromProps) {\n      return id;\n    } else {\n      return order ? `${order}:${JSON.stringify(constraints)}` : JSON.stringify(constraints);\n    }\n  }).sort((a, b) => a.localeCompare(b)).join(\",\");\n}\nfunction loadSerializedPanelGroupState(autoSaveId, storage) {\n  try {\n    const panelGroupKey = getPanelGroupKey(autoSaveId);\n    const serialized = storage.getItem(panelGroupKey);\n    if (serialized) {\n      const parsed = JSON.parse(serialized);\n      if (typeof parsed === \"object\" && parsed != null) {\n        return parsed;\n      }\n    }\n  } catch (error) {}\n  return null;\n}\nfunction loadPanelGroupState(autoSaveId, panels, storage) {\n  var _loadSerializedPanelG, _state$panelKey;\n  const state = (_loadSerializedPanelG = loadSerializedPanelGroupState(autoSaveId, storage)) !== null && _loadSerializedPanelG !== void 0 ? _loadSerializedPanelG : {};\n  const panelKey = getPanelKey(panels);\n  return (_state$panelKey = state[panelKey]) !== null && _state$panelKey !== void 0 ? _state$panelKey : null;\n}\nfunction savePanelGroupState(autoSaveId, panels, panelSizesBeforeCollapse, sizes, storage) {\n  var _loadSerializedPanelG2;\n  const panelGroupKey = getPanelGroupKey(autoSaveId);\n  const panelKey = getPanelKey(panels);\n  const state = (_loadSerializedPanelG2 = loadSerializedPanelGroupState(autoSaveId, storage)) !== null && _loadSerializedPanelG2 !== void 0 ? _loadSerializedPanelG2 : {};\n  state[panelKey] = {\n    expandToSizes: Object.fromEntries(panelSizesBeforeCollapse.entries()),\n    layout: sizes\n  };\n  try {\n    storage.setItem(panelGroupKey, JSON.stringify(state));\n  } catch (error) {\n    console.error(error);\n  }\n}\n\n// All units must be in percentages; pixel values should be pre-converted\nfunction validatePanelGroupLayout({\n  layout: prevLayout,\n  panelConstraints\n}) {\n  const nextLayout = [...prevLayout];\n  const nextLayoutTotalSize = nextLayout.reduce((accumulated, current) => accumulated + current, 0);\n\n  // Validate layout expectations\n  if (nextLayout.length !== panelConstraints.length) {\n    throw Error(`Invalid ${panelConstraints.length} panel layout: ${nextLayout.map(size => `${size}%`).join(\", \")}`);\n  } else if (!fuzzyNumbersEqual(nextLayoutTotalSize, 100) && nextLayout.length > 0) {\n    for (let index = 0; index < panelConstraints.length; index++) {\n      const unsafeSize = nextLayout[index];\n      assert(unsafeSize != null, `No layout data found for index ${index}`);\n      const safeSize = 100 / nextLayoutTotalSize * unsafeSize;\n      nextLayout[index] = safeSize;\n    }\n  }\n  let remainingSize = 0;\n\n  // First pass: Validate the proposed layout given each panel's constraints\n  for (let index = 0; index < panelConstraints.length; index++) {\n    const unsafeSize = nextLayout[index];\n    assert(unsafeSize != null, `No layout data found for index ${index}`);\n    const safeSize = resizePanel({\n      panelConstraints,\n      panelIndex: index,\n      size: unsafeSize\n    });\n    if (unsafeSize != safeSize) {\n      remainingSize += unsafeSize - safeSize;\n      nextLayout[index] = safeSize;\n    }\n  }\n\n  // If there is additional, left over space, assign it to any panel(s) that permits it\n  // (It's not worth taking multiple additional passes to evenly distribute)\n  if (!fuzzyNumbersEqual(remainingSize, 0)) {\n    for (let index = 0; index < panelConstraints.length; index++) {\n      const prevSize = nextLayout[index];\n      assert(prevSize != null, `No layout data found for index ${index}`);\n      const unsafeSize = prevSize + remainingSize;\n      const safeSize = resizePanel({\n        panelConstraints,\n        panelIndex: index,\n        size: unsafeSize\n      });\n      if (prevSize !== safeSize) {\n        remainingSize -= safeSize - prevSize;\n        nextLayout[index] = safeSize;\n\n        // Once we've used up the remainder, bail\n        if (fuzzyNumbersEqual(remainingSize, 0)) {\n          break;\n        }\n      }\n    }\n  }\n  return nextLayout;\n}\n\nconst LOCAL_STORAGE_DEBOUNCE_INTERVAL = 100;\nconst defaultStorage = {\n  getItem: name => {\n    initializeDefaultStorage(defaultStorage);\n    return defaultStorage.getItem(name);\n  },\n  setItem: (name, value) => {\n    initializeDefaultStorage(defaultStorage);\n    defaultStorage.setItem(name, value);\n  }\n};\nconst debounceMap = {};\nfunction PanelGroupWithForwardedRef({\n  autoSaveId = null,\n  children,\n  className: classNameFromProps = \"\",\n  direction,\n  forwardedRef,\n  id: idFromProps = null,\n  onLayout = null,\n  keyboardResizeBy = null,\n  storage = defaultStorage,\n  style: styleFromProps,\n  tagName: Type = \"div\",\n  ...rest\n}) {\n  const groupId = useUniqueId(idFromProps);\n  const panelGroupElementRef = useRef(null);\n  const [dragState, setDragState] = useState(null);\n  const [layout, setLayout] = useState([]);\n  const forceUpdate = useForceUpdate();\n  const panelIdToLastNotifiedSizeMapRef = useRef({});\n  const panelSizeBeforeCollapseRef = useRef(new Map());\n  const prevDeltaRef = useRef(0);\n  const committedValuesRef = useRef({\n    autoSaveId,\n    direction,\n    dragState,\n    id: groupId,\n    keyboardResizeBy,\n    onLayout,\n    storage\n  });\n  const eagerValuesRef = useRef({\n    layout,\n    panelDataArray: [],\n    panelDataArrayChanged: false\n  });\n  useRef({\n    didLogIdAndOrderWarning: false,\n    didLogPanelConstraintsWarning: false,\n    prevPanelIds: []\n  });\n  useImperativeHandle(forwardedRef, () => ({\n    getId: () => committedValuesRef.current.id,\n    getLayout: () => {\n      const {\n        layout\n      } = eagerValuesRef.current;\n      return layout;\n    },\n    setLayout: unsafeLayout => {\n      const {\n        onLayout\n      } = committedValuesRef.current;\n      const {\n        layout: prevLayout,\n        panelDataArray\n      } = eagerValuesRef.current;\n      const safeLayout = validatePanelGroupLayout({\n        layout: unsafeLayout,\n        panelConstraints: panelDataArray.map(panelData => panelData.constraints)\n      });\n      if (!areEqual(prevLayout, safeLayout)) {\n        setLayout(safeLayout);\n        eagerValuesRef.current.layout = safeLayout;\n        if (onLayout) {\n          onLayout(safeLayout);\n        }\n        callPanelCallbacks(panelDataArray, safeLayout, panelIdToLastNotifiedSizeMapRef.current);\n      }\n    }\n  }), []);\n  useIsomorphicLayoutEffect(() => {\n    committedValuesRef.current.autoSaveId = autoSaveId;\n    committedValuesRef.current.direction = direction;\n    committedValuesRef.current.dragState = dragState;\n    committedValuesRef.current.id = groupId;\n    committedValuesRef.current.onLayout = onLayout;\n    committedValuesRef.current.storage = storage;\n  });\n  useWindowSplitterPanelGroupBehavior({\n    committedValuesRef,\n    eagerValuesRef,\n    groupId,\n    layout,\n    panelDataArray: eagerValuesRef.current.panelDataArray,\n    setLayout,\n    panelGroupElement: panelGroupElementRef.current\n  });\n  useEffect(() => {\n    const {\n      panelDataArray\n    } = eagerValuesRef.current;\n\n    // If this panel has been configured to persist sizing information, save sizes to local storage.\n    if (autoSaveId) {\n      if (layout.length === 0 || layout.length !== panelDataArray.length) {\n        return;\n      }\n      let debouncedSave = debounceMap[autoSaveId];\n\n      // Limit the frequency of localStorage updates.\n      if (debouncedSave == null) {\n        debouncedSave = debounce(savePanelGroupState, LOCAL_STORAGE_DEBOUNCE_INTERVAL);\n        debounceMap[autoSaveId] = debouncedSave;\n      }\n\n      // Clone mutable data before passing to the debounced function,\n      // else we run the risk of saving an incorrect combination of mutable and immutable values to state.\n      const clonedPanelDataArray = [...panelDataArray];\n      const clonedPanelSizesBeforeCollapse = new Map(panelSizeBeforeCollapseRef.current);\n      debouncedSave(autoSaveId, clonedPanelDataArray, clonedPanelSizesBeforeCollapse, layout, storage);\n    }\n  }, [autoSaveId, layout, storage]);\n\n  // DEV warnings\n  useEffect(() => {\n  });\n\n  // External APIs are safe to memoize via committed values ref\n  const collapsePanel = useCallback(panelData => {\n    const {\n      onLayout\n    } = committedValuesRef.current;\n    const {\n      layout: prevLayout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    if (panelData.constraints.collapsible) {\n      const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);\n      const {\n        collapsedSize = 0,\n        panelSize,\n        pivotIndices\n      } = panelDataHelper(panelDataArray, panelData, prevLayout);\n      assert(panelSize != null, `Panel size not found for panel \"${panelData.id}\"`);\n      if (!fuzzyNumbersEqual$1(panelSize, collapsedSize)) {\n        // Store size before collapse;\n        // This is the size that gets restored if the expand() API is used.\n        panelSizeBeforeCollapseRef.current.set(panelData.id, panelSize);\n        const isLastPanel = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1;\n        const delta = isLastPanel ? panelSize - collapsedSize : collapsedSize - panelSize;\n        const nextLayout = adjustLayoutByDelta({\n          delta,\n          initialLayout: prevLayout,\n          panelConstraints: panelConstraintsArray,\n          pivotIndices,\n          prevLayout,\n          trigger: \"imperative-api\"\n        });\n        if (!compareLayouts(prevLayout, nextLayout)) {\n          setLayout(nextLayout);\n          eagerValuesRef.current.layout = nextLayout;\n          if (onLayout) {\n            onLayout(nextLayout);\n          }\n          callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);\n        }\n      }\n    }\n  }, []);\n\n  // External APIs are safe to memoize via committed values ref\n  const expandPanel = useCallback((panelData, minSizeOverride) => {\n    const {\n      onLayout\n    } = committedValuesRef.current;\n    const {\n      layout: prevLayout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    if (panelData.constraints.collapsible) {\n      const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);\n      const {\n        collapsedSize = 0,\n        panelSize = 0,\n        minSize: minSizeFromProps = 0,\n        pivotIndices\n      } = panelDataHelper(panelDataArray, panelData, prevLayout);\n      const minSize = minSizeOverride !== null && minSizeOverride !== void 0 ? minSizeOverride : minSizeFromProps;\n      if (fuzzyNumbersEqual$1(panelSize, collapsedSize)) {\n        // Restore this panel to the size it was before it was collapsed, if possible.\n        const prevPanelSize = panelSizeBeforeCollapseRef.current.get(panelData.id);\n        const baseSize = prevPanelSize != null && prevPanelSize >= minSize ? prevPanelSize : minSize;\n        const isLastPanel = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1;\n        const delta = isLastPanel ? panelSize - baseSize : baseSize - panelSize;\n        const nextLayout = adjustLayoutByDelta({\n          delta,\n          initialLayout: prevLayout,\n          panelConstraints: panelConstraintsArray,\n          pivotIndices,\n          prevLayout,\n          trigger: \"imperative-api\"\n        });\n        if (!compareLayouts(prevLayout, nextLayout)) {\n          setLayout(nextLayout);\n          eagerValuesRef.current.layout = nextLayout;\n          if (onLayout) {\n            onLayout(nextLayout);\n          }\n          callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);\n        }\n      }\n    }\n  }, []);\n\n  // External APIs are safe to memoize via committed values ref\n  const getPanelSize = useCallback(panelData => {\n    const {\n      layout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    const {\n      panelSize\n    } = panelDataHelper(panelDataArray, panelData, layout);\n    assert(panelSize != null, `Panel size not found for panel \"${panelData.id}\"`);\n    return panelSize;\n  }, []);\n\n  // This API should never read from committedValuesRef\n  const getPanelStyle = useCallback((panelData, defaultSize) => {\n    const {\n      panelDataArray\n    } = eagerValuesRef.current;\n    const panelIndex = findPanelDataIndex(panelDataArray, panelData);\n    return computePanelFlexBoxStyle({\n      defaultSize,\n      dragState,\n      layout,\n      panelData: panelDataArray,\n      panelIndex\n    });\n  }, [dragState, layout]);\n\n  // External APIs are safe to memoize via committed values ref\n  const isPanelCollapsed = useCallback(panelData => {\n    const {\n      layout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    const {\n      collapsedSize = 0,\n      collapsible,\n      panelSize\n    } = panelDataHelper(panelDataArray, panelData, layout);\n    assert(panelSize != null, `Panel size not found for panel \"${panelData.id}\"`);\n    return collapsible === true && fuzzyNumbersEqual$1(panelSize, collapsedSize);\n  }, []);\n\n  // External APIs are safe to memoize via committed values ref\n  const isPanelExpanded = useCallback(panelData => {\n    const {\n      layout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    const {\n      collapsedSize = 0,\n      collapsible,\n      panelSize\n    } = panelDataHelper(panelDataArray, panelData, layout);\n    assert(panelSize != null, `Panel size not found for panel \"${panelData.id}\"`);\n    return !collapsible || fuzzyCompareNumbers(panelSize, collapsedSize) > 0;\n  }, []);\n  const registerPanel = useCallback(panelData => {\n    const {\n      panelDataArray\n    } = eagerValuesRef.current;\n    panelDataArray.push(panelData);\n    panelDataArray.sort((panelA, panelB) => {\n      const orderA = panelA.order;\n      const orderB = panelB.order;\n      if (orderA == null && orderB == null) {\n        return 0;\n      } else if (orderA == null) {\n        return -1;\n      } else if (orderB == null) {\n        return 1;\n      } else {\n        return orderA - orderB;\n      }\n    });\n    eagerValuesRef.current.panelDataArrayChanged = true;\n    forceUpdate();\n  }, [forceUpdate]);\n\n  // (Re)calculate group layout whenever panels are registered or unregistered.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  useIsomorphicLayoutEffect(() => {\n    if (eagerValuesRef.current.panelDataArrayChanged) {\n      eagerValuesRef.current.panelDataArrayChanged = false;\n      const {\n        autoSaveId,\n        onLayout,\n        storage\n      } = committedValuesRef.current;\n      const {\n        layout: prevLayout,\n        panelDataArray\n      } = eagerValuesRef.current;\n\n      // If this panel has been configured to persist sizing information,\n      // default size should be restored from local storage if possible.\n      let unsafeLayout = null;\n      if (autoSaveId) {\n        const state = loadPanelGroupState(autoSaveId, panelDataArray, storage);\n        if (state) {\n          panelSizeBeforeCollapseRef.current = new Map(Object.entries(state.expandToSizes));\n          unsafeLayout = state.layout;\n        }\n      }\n      if (unsafeLayout == null) {\n        unsafeLayout = calculateUnsafeDefaultLayout({\n          panelDataArray\n        });\n      }\n\n      // Validate even saved layouts in case something has changed since last render\n      // e.g. for pixel groups, this could be the size of the window\n      const nextLayout = validatePanelGroupLayout({\n        layout: unsafeLayout,\n        panelConstraints: panelDataArray.map(panelData => panelData.constraints)\n      });\n      if (!areEqual(prevLayout, nextLayout)) {\n        setLayout(nextLayout);\n        eagerValuesRef.current.layout = nextLayout;\n        if (onLayout) {\n          onLayout(nextLayout);\n        }\n        callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);\n      }\n    }\n  });\n\n  // Reset the cached layout if hidden by the Activity/Offscreen API\n  useIsomorphicLayoutEffect(() => {\n    const eagerValues = eagerValuesRef.current;\n    return () => {\n      eagerValues.layout = [];\n    };\n  }, []);\n  const registerResizeHandle = useCallback(dragHandleId => {\n    let isRTL = false;\n    const panelGroupElement = panelGroupElementRef.current;\n    if (panelGroupElement) {\n      const style = window.getComputedStyle(panelGroupElement, null);\n      if (style.getPropertyValue(\"direction\") === \"rtl\") {\n        isRTL = true;\n      }\n    }\n    return function resizeHandler(event) {\n      event.preventDefault();\n      const panelGroupElement = panelGroupElementRef.current;\n      if (!panelGroupElement) {\n        return () => null;\n      }\n      const {\n        direction,\n        dragState,\n        id: groupId,\n        keyboardResizeBy,\n        onLayout\n      } = committedValuesRef.current;\n      const {\n        layout: prevLayout,\n        panelDataArray\n      } = eagerValuesRef.current;\n      const {\n        initialLayout\n      } = dragState !== null && dragState !== void 0 ? dragState : {};\n      const pivotIndices = determinePivotIndices(groupId, dragHandleId, panelGroupElement);\n      let delta = calculateDeltaPercentage(event, dragHandleId, direction, dragState, keyboardResizeBy, panelGroupElement);\n      const isHorizontal = direction === \"horizontal\";\n      if (isHorizontal && isRTL) {\n        delta = -delta;\n      }\n      const panelConstraints = panelDataArray.map(panelData => panelData.constraints);\n      const nextLayout = adjustLayoutByDelta({\n        delta,\n        initialLayout: initialLayout !== null && initialLayout !== void 0 ? initialLayout : prevLayout,\n        panelConstraints,\n        pivotIndices,\n        prevLayout,\n        trigger: isKeyDown(event) ? \"keyboard\" : \"mouse-or-touch\"\n      });\n      const layoutChanged = !compareLayouts(prevLayout, nextLayout);\n\n      // Only update the cursor for layout changes triggered by touch/mouse events (not keyboard)\n      // Update the cursor even if the layout hasn't changed (we may need to show an invalid cursor state)\n      if (isPointerEvent(event) || isMouseEvent(event)) {\n        // Watch for multiple subsequent deltas; this might occur for tiny cursor movements.\n        // In this case, Panel sizes might not change–\n        // but updating cursor in this scenario would cause a flicker.\n        if (prevDeltaRef.current != delta) {\n          prevDeltaRef.current = delta;\n          if (!layoutChanged && delta !== 0) {\n            // If the pointer has moved too far to resize the panel any further, note this so we can update the cursor.\n            // This mimics VS Code behavior.\n            if (isHorizontal) {\n              reportConstraintsViolation(dragHandleId, delta < 0 ? EXCEEDED_HORIZONTAL_MIN : EXCEEDED_HORIZONTAL_MAX);\n            } else {\n              reportConstraintsViolation(dragHandleId, delta < 0 ? EXCEEDED_VERTICAL_MIN : EXCEEDED_VERTICAL_MAX);\n            }\n          } else {\n            reportConstraintsViolation(dragHandleId, 0);\n          }\n        }\n      }\n      if (layoutChanged) {\n        setLayout(nextLayout);\n        eagerValuesRef.current.layout = nextLayout;\n        if (onLayout) {\n          onLayout(nextLayout);\n        }\n        callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);\n      }\n    };\n  }, []);\n\n  // External APIs are safe to memoize via committed values ref\n  const resizePanel = useCallback((panelData, unsafePanelSize) => {\n    const {\n      onLayout\n    } = committedValuesRef.current;\n    const {\n      layout: prevLayout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    const panelConstraintsArray = panelDataArray.map(panelData => panelData.constraints);\n    const {\n      panelSize,\n      pivotIndices\n    } = panelDataHelper(panelDataArray, panelData, prevLayout);\n    assert(panelSize != null, `Panel size not found for panel \"${panelData.id}\"`);\n    const isLastPanel = findPanelDataIndex(panelDataArray, panelData) === panelDataArray.length - 1;\n    const delta = isLastPanel ? panelSize - unsafePanelSize : unsafePanelSize - panelSize;\n    const nextLayout = adjustLayoutByDelta({\n      delta,\n      initialLayout: prevLayout,\n      panelConstraints: panelConstraintsArray,\n      pivotIndices,\n      prevLayout,\n      trigger: \"imperative-api\"\n    });\n    if (!compareLayouts(prevLayout, nextLayout)) {\n      setLayout(nextLayout);\n      eagerValuesRef.current.layout = nextLayout;\n      if (onLayout) {\n        onLayout(nextLayout);\n      }\n      callPanelCallbacks(panelDataArray, nextLayout, panelIdToLastNotifiedSizeMapRef.current);\n    }\n  }, []);\n  const reevaluatePanelConstraints = useCallback((panelData, prevConstraints) => {\n    const {\n      layout,\n      panelDataArray\n    } = eagerValuesRef.current;\n    const {\n      collapsedSize: prevCollapsedSize = 0,\n      collapsible: prevCollapsible\n    } = prevConstraints;\n    const {\n      collapsedSize: nextCollapsedSize = 0,\n      collapsible: nextCollapsible,\n      maxSize: nextMaxSize = 100,\n      minSize: nextMinSize = 0\n    } = panelData.constraints;\n    const {\n      panelSize: prevPanelSize\n    } = panelDataHelper(panelDataArray, panelData, layout);\n    if (prevPanelSize == null) {\n      // It's possible that the panels in this group have changed since the last render\n      return;\n    }\n    if (prevCollapsible && nextCollapsible && fuzzyNumbersEqual$1(prevPanelSize, prevCollapsedSize)) {\n      if (!fuzzyNumbersEqual$1(prevCollapsedSize, nextCollapsedSize)) {\n        resizePanel(panelData, nextCollapsedSize);\n      }\n    } else if (prevPanelSize < nextMinSize) {\n      resizePanel(panelData, nextMinSize);\n    } else if (prevPanelSize > nextMaxSize) {\n      resizePanel(panelData, nextMaxSize);\n    }\n  }, [resizePanel]);\n\n  // TODO Multiple drag handles can be active at the same time so this API is a bit awkward now\n  const startDragging = useCallback((dragHandleId, event) => {\n    const {\n      direction\n    } = committedValuesRef.current;\n    const {\n      layout\n    } = eagerValuesRef.current;\n    if (!panelGroupElementRef.current) {\n      return;\n    }\n    const handleElement = getResizeHandleElement(dragHandleId, panelGroupElementRef.current);\n    assert(handleElement, `Drag handle element not found for id \"${dragHandleId}\"`);\n    const initialCursorPosition = getResizeEventCursorPosition(direction, event);\n    setDragState({\n      dragHandleId,\n      dragHandleRect: handleElement.getBoundingClientRect(),\n      initialCursorPosition,\n      initialLayout: layout\n    });\n  }, []);\n  const stopDragging = useCallback(() => {\n    setDragState(null);\n  }, []);\n  const unregisterPanel = useCallback(panelData => {\n    const {\n      panelDataArray\n    } = eagerValuesRef.current;\n    const index = findPanelDataIndex(panelDataArray, panelData);\n    if (index >= 0) {\n      panelDataArray.splice(index, 1);\n\n      // TRICKY\n      // When a panel is removed from the group, we should delete the most recent prev-size entry for it.\n      // If we don't do this, then a conditionally rendered panel might not call onResize when it's re-mounted.\n      // Strict effects mode makes this tricky though because all panels will be registered, unregistered, then re-registered on mount.\n      delete panelIdToLastNotifiedSizeMapRef.current[panelData.id];\n      eagerValuesRef.current.panelDataArrayChanged = true;\n      forceUpdate();\n    }\n  }, [forceUpdate]);\n  const context = useMemo(() => ({\n    collapsePanel,\n    direction,\n    dragState,\n    expandPanel,\n    getPanelSize,\n    getPanelStyle,\n    groupId,\n    isPanelCollapsed,\n    isPanelExpanded,\n    reevaluatePanelConstraints,\n    registerPanel,\n    registerResizeHandle,\n    resizePanel,\n    startDragging,\n    stopDragging,\n    unregisterPanel,\n    panelGroupElement: panelGroupElementRef.current\n  }), [collapsePanel, dragState, direction, expandPanel, getPanelSize, getPanelStyle, groupId, isPanelCollapsed, isPanelExpanded, reevaluatePanelConstraints, registerPanel, registerResizeHandle, resizePanel, startDragging, stopDragging, unregisterPanel]);\n  const style = {\n    display: \"flex\",\n    flexDirection: direction === \"horizontal\" ? \"row\" : \"column\",\n    height: \"100%\",\n    overflow: \"hidden\",\n    width: \"100%\"\n  };\n  return createElement(PanelGroupContext.Provider, {\n    value: context\n  }, createElement(Type, {\n    ...rest,\n    children,\n    className: classNameFromProps,\n    id: idFromProps,\n    ref: panelGroupElementRef,\n    style: {\n      ...style,\n      ...styleFromProps\n    },\n    // CSS selectors\n    \"data-panel-group\": \"\",\n    \"data-panel-group-direction\": direction,\n    \"data-panel-group-id\": groupId\n  }));\n}\nconst PanelGroup = forwardRef((props, ref) => createElement(PanelGroupWithForwardedRef, {\n  ...props,\n  forwardedRef: ref\n}));\nPanelGroupWithForwardedRef.displayName = \"PanelGroup\";\nPanelGroup.displayName = \"forwardRef(PanelGroup)\";\nfunction findPanelDataIndex(panelDataArray, panelData) {\n  return panelDataArray.findIndex(prevPanelData => prevPanelData === panelData || prevPanelData.id === panelData.id);\n}\nfunction panelDataHelper(panelDataArray, panelData, layout) {\n  const panelIndex = findPanelDataIndex(panelDataArray, panelData);\n  const isLastPanel = panelIndex === panelDataArray.length - 1;\n  const pivotIndices = isLastPanel ? [panelIndex - 1, panelIndex] : [panelIndex, panelIndex + 1];\n  const panelSize = layout[panelIndex];\n  return {\n    ...panelData.constraints,\n    panelSize,\n    pivotIndices\n  };\n}\n\n// https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/\n\nfunction useWindowSplitterResizeHandlerBehavior({\n  disabled,\n  handleId,\n  resizeHandler,\n  panelGroupElement\n}) {\n  useEffect(() => {\n    if (disabled || resizeHandler == null || panelGroupElement == null) {\n      return;\n    }\n    const handleElement = getResizeHandleElement(handleId, panelGroupElement);\n    if (handleElement == null) {\n      return;\n    }\n    const onKeyDown = event => {\n      if (event.defaultPrevented) {\n        return;\n      }\n      switch (event.key) {\n        case \"ArrowDown\":\n        case \"ArrowLeft\":\n        case \"ArrowRight\":\n        case \"ArrowUp\":\n        case \"End\":\n        case \"Home\":\n          {\n            event.preventDefault();\n            resizeHandler(event);\n            break;\n          }\n        case \"F6\":\n          {\n            event.preventDefault();\n            const groupId = handleElement.getAttribute(\"data-panel-group-id\");\n            assert(groupId, `No group element found for id \"${groupId}\"`);\n            const handles = getResizeHandleElementsForGroup(groupId, panelGroupElement);\n            const index = getResizeHandleElementIndex(groupId, handleId, panelGroupElement);\n            assert(index !== null, `No resize element found for id \"${handleId}\"`);\n            const nextIndex = event.shiftKey ? index > 0 ? index - 1 : handles.length - 1 : index + 1 < handles.length ? index + 1 : 0;\n            const nextHandle = handles[nextIndex];\n            nextHandle.focus();\n            break;\n          }\n      }\n    };\n    handleElement.addEventListener(\"keydown\", onKeyDown);\n    return () => {\n      handleElement.removeEventListener(\"keydown\", onKeyDown);\n    };\n  }, [panelGroupElement, disabled, handleId, resizeHandler]);\n}\n\nfunction PanelResizeHandle({\n  children = null,\n  className: classNameFromProps = \"\",\n  disabled = false,\n  hitAreaMargins,\n  id: idFromProps,\n  onBlur,\n  onDragging,\n  onFocus,\n  style: styleFromProps = {},\n  tabIndex = 0,\n  tagName: Type = \"div\",\n  ...rest\n}) {\n  var _hitAreaMargins$coars, _hitAreaMargins$fine;\n  const elementRef = useRef(null);\n\n  // Use a ref to guard against users passing inline props\n  const callbacksRef = useRef({\n    onDragging\n  });\n  useEffect(() => {\n    callbacksRef.current.onDragging = onDragging;\n  });\n  const panelGroupContext = useContext(PanelGroupContext);\n  if (panelGroupContext === null) {\n    throw Error(`PanelResizeHandle components must be rendered within a PanelGroup container`);\n  }\n  const {\n    direction,\n    groupId,\n    registerResizeHandle: registerResizeHandleWithParentGroup,\n    startDragging,\n    stopDragging,\n    panelGroupElement\n  } = panelGroupContext;\n  const resizeHandleId = useUniqueId(idFromProps);\n  const [state, setState] = useState(\"inactive\");\n  const [isFocused, setIsFocused] = useState(false);\n  const [resizeHandler, setResizeHandler] = useState(null);\n  const committedValuesRef = useRef({\n    state\n  });\n  useIsomorphicLayoutEffect(() => {\n    committedValuesRef.current.state = state;\n  });\n  useEffect(() => {\n    if (disabled) {\n      setResizeHandler(null);\n    } else {\n      const resizeHandler = registerResizeHandleWithParentGroup(resizeHandleId);\n      setResizeHandler(() => resizeHandler);\n    }\n  }, [disabled, resizeHandleId, registerResizeHandleWithParentGroup]);\n\n  // Extract hit area margins before passing them to the effect's dependency array\n  // so that inline object values won't trigger re-renders\n  const coarseHitAreaMargins = (_hitAreaMargins$coars = hitAreaMargins === null || hitAreaMargins === void 0 ? void 0 : hitAreaMargins.coarse) !== null && _hitAreaMargins$coars !== void 0 ? _hitAreaMargins$coars : 15;\n  const fineHitAreaMargins = (_hitAreaMargins$fine = hitAreaMargins === null || hitAreaMargins === void 0 ? void 0 : hitAreaMargins.fine) !== null && _hitAreaMargins$fine !== void 0 ? _hitAreaMargins$fine : 5;\n  useEffect(() => {\n    if (disabled || resizeHandler == null) {\n      return;\n    }\n    const element = elementRef.current;\n    assert(element, \"Element ref not attached\");\n    const setResizeHandlerState = (action, isActive, event) => {\n      if (isActive) {\n        switch (action) {\n          case \"down\":\n            {\n              setState(\"drag\");\n              assert(event, 'Expected event to be defined for \"down\" action');\n              startDragging(resizeHandleId, event);\n              const {\n                onDragging\n              } = callbacksRef.current;\n              if (onDragging) {\n                onDragging(true);\n              }\n              break;\n            }\n          case \"move\":\n            {\n              const {\n                state\n              } = committedValuesRef.current;\n              if (state !== \"drag\") {\n                setState(\"hover\");\n              }\n              assert(event, 'Expected event to be defined for \"move\" action');\n              resizeHandler(event);\n              break;\n            }\n          case \"up\":\n            {\n              setState(\"hover\");\n              stopDragging();\n              const {\n                onDragging\n              } = callbacksRef.current;\n              if (onDragging) {\n                onDragging(false);\n              }\n              break;\n            }\n        }\n      } else {\n        setState(\"inactive\");\n      }\n    };\n    return registerResizeHandle(resizeHandleId, element, direction, {\n      coarse: coarseHitAreaMargins,\n      fine: fineHitAreaMargins\n    }, setResizeHandlerState);\n  }, [coarseHitAreaMargins, direction, disabled, fineHitAreaMargins, registerResizeHandleWithParentGroup, resizeHandleId, resizeHandler, startDragging, stopDragging]);\n  useWindowSplitterResizeHandlerBehavior({\n    disabled,\n    handleId: resizeHandleId,\n    resizeHandler,\n    panelGroupElement\n  });\n  const style = {\n    touchAction: \"none\",\n    userSelect: \"none\"\n  };\n  return createElement(Type, {\n    ...rest,\n    children,\n    className: classNameFromProps,\n    id: idFromProps,\n    onBlur: () => {\n      setIsFocused(false);\n      onBlur === null || onBlur === void 0 ? void 0 : onBlur();\n    },\n    onFocus: () => {\n      setIsFocused(true);\n      onFocus === null || onFocus === void 0 ? void 0 : onFocus();\n    },\n    ref: elementRef,\n    role: \"separator\",\n    style: {\n      ...style,\n      ...styleFromProps\n    },\n    tabIndex,\n    // CSS selectors\n    \"data-panel-group-direction\": direction,\n    \"data-panel-group-id\": groupId,\n    \"data-resize-handle\": \"\",\n    \"data-resize-handle-active\": state === \"drag\" ? \"pointer\" : isFocused ? \"keyboard\" : undefined,\n    \"data-resize-handle-state\": state,\n    \"data-panel-resize-handle-enabled\": !disabled,\n    \"data-panel-resize-handle-id\": resizeHandleId\n  });\n}\nPanelResizeHandle.displayName = \"PanelResizeHandle\";\n\nfunction getPanelElement(id, scope = document) {\n  const element = scope.querySelector(`[data-panel-id=\"${id}\"]`);\n  if (element) {\n    return element;\n  }\n  return null;\n}\n\nfunction getPanelElementsForGroup(groupId, scope = document) {\n  return Array.from(scope.querySelectorAll(`[data-panel][data-panel-group-id=\"${groupId}\"]`));\n}\n\nfunction getIntersectingRectangle(rectOne, rectTwo, strict) {\n  if (!intersects(rectOne, rectTwo, strict)) {\n    return {\n      x: 0,\n      y: 0,\n      width: 0,\n      height: 0\n    };\n  }\n  return {\n    x: Math.max(rectOne.x, rectTwo.x),\n    y: Math.max(rectOne.y, rectTwo.y),\n    width: Math.min(rectOne.x + rectOne.width, rectTwo.x + rectTwo.width) - Math.max(rectOne.x, rectTwo.x),\n    height: Math.min(rectOne.y + rectOne.height, rectTwo.y + rectTwo.height) - Math.max(rectOne.y, rectTwo.y)\n  };\n}\n\nexport { Panel, PanelGroup, PanelResizeHandle, assert, disableGlobalCursorStyles, enableGlobalCursorStyles, getIntersectingRectangle, getPanelElement, getPanelElementsForGroup, getPanelGroupElement, getResizeHandleElement, getResizeHandleElementIndex, getResizeHandleElementsForGroup, getResizeHandlePanelIds, intersects, setNonce };\n"],"names":["createElement","createContext","createRef","forwardRef","useCallback","useContext","useEffect","useImperativeHandle","useLayoutEffect","useMemo","useRef","useState","React","useId","Math","random","slice","useLayoutEffect_do_not_use_directly","PanelGroupContext","displayName","useIsomorphicLayoutEffect","wrappedUseId","counter","useUniqueId","idFromParams","idFromUseId","idRef","current","PanelWithForwardedRef","children","className","classNameFromProps","collapsedSize","collapsible","defaultSize","forwardedRef","id","idFromProps","maxSize","minSize","onCollapse","onExpand","onResize","order","style","styleFromProps","tagName","Type","rest","context","Error","collapsePanel","expandPanel","getPanelSize","getPanelStyle","groupId","isPanelCollapsed","reevaluatePanelConstraints","registerPanel","resizePanel","unregisterPanel","panelId","panelDataRef","callbacks","constraints","idIsFromProps","didLogMissingDefaultSizeWarning","prevConstraints","panelData","collapse","expand","getId","getSize","isCollapsed","isExpanded","resize","size","parseFloat","flexGrow","toFixed","Panel","props","ref","currentCursorStyle","styleElement","setGlobalCursorStyle","state","constraintFlags","verticalMin","EXCEEDED_VERTICAL_MIN","verticalMax","EXCEEDED_VERTICAL_MAX","EXCEEDED_HORIZONTAL_MIN","EXCEEDED_HORIZONTAL_MAX","getCursorStyle","document","head","appendChild","innerHTML","isKeyDown","event","type","isPointerEvent","startsWith","isMouseEvent","getResizeEventCoordinates","isPrimary","x","clientX","y","clientY","Infinity","creates_stacking_context","node","getComputedStyle","position","zIndex","_get_parent","display","get_parent","is_flex_item","opacity","transform","webkitTransform","mixBlendMode","filter","webkitFilter","isolation","test","willChange","webkitOverflowScrolling","find_stacking_context","nodes","i","length","assert","get_z_index","Number","get_ancestors","ancestors","push","parentNode","ShadowRoot","host","isCoarsePointer","matchMedia","matches","getInputType","intersectingHandles","isPointerDown","ownerDocumentCounts","Map","panelConstraintFlags","registeredResizeHandlers","Set","handlePointerDown","target","recalculateIntersectingHandles","updateResizeHandlerStates","preventDefault","stopPropagation","handlePointerMove","buttons","handlePointerUp","clear","splice","targetElement","HTMLElement","SVGElement","forEach","data","element","dragHandleElement","hitAreaMargins","dragHandleRect","getBoundingClientRect","bottom","left","right","top","margin","coarse","fine","contains","a","b","common_ancestor","at","pop","z_indexes","childNodes","furthest_ancestors","child","sign","compare","currentElement","didIntersect","rectOne","rectTwo","width","height","parentElement","reportConstraintsViolation","resizeHandleId","flag","set","updateCursor","intersectsHorizontal","intersectsVertical","direction","removeChild","updateListeners","_","ownerDocument","body","removeEventListener","window","count","addEventListener","capture","action","setResizeHandlerState","isActive","includes","expectedCondition","message","console","error","PRECISION","fuzzyCompareNumbers","actual","expected","fractionDigits","fuzzyNumbersEqual$1","fuzzyNumbersEqual","panelConstraints","panelConstraintsArray","panelIndex","min","adjustLayoutByDelta","delta","initialLayout","pivotIndices","prevLayout","trigger","nextLayout","firstPivotIndex","secondPivotIndex","deltaApplied","index","prevSize","localDelta","abs","increment","maxAvailableDelta","minAbsDelta","deltaRemaining","safeSize","toPrecision","localeCompare","numeric","fuzzyLayoutsEqual","pivotIndex","unsafeSize","reduce","total","calculateAriaValues","layout","panelsArray","currentMinSize","currentMaxSize","totalMinSize","totalMaxSize","firstIndex","valueMax","valueMin","max","valueNow","getResizeHandleElementsForGroup","scope","Array","from","querySelectorAll","getResizeHandleElementIndex","findIndex","handle","getAttribute","determinePivotIndices","dragHandleId","panelGroupElement","getPanelGroupElement","rootElement","_dataset","dataset","panelGroupId","querySelector","getResizeHandleElement","useWindowSplitterPanelGroupBehavior","committedValuesRef","eagerValuesRef","panelDataArray","setLayout","didWarnAboutMissingResizeHandle","resizeHandleElements","resizeHandleElement","setAttribute","round","removeAttribute","eagerValues","handles","cleanupFunctions","map","handleId","idBefore","idAfter","_panelsArray$index$id","_panelsArray$index","_panelsArray$id","_panelsArray","indexOf","getResizeHandlePanelIds","onKeyDown","defaultPrevented","key","cleanupFunction","areEqual","arrayA","arrayB","getResizeEventCursorPosition","isHorizontal","calculateDeltaPercentage","initialDragState","keyboardResizeBy","shiftKey","movement","handleElement","initialCursorPosition","cursorPosition","groupElement","groupRect","calculateDragOffsetPercentage","callPanelCallbacks","panelIdToLastNotifiedSizeMap","lastNotifiedSize","compareLayouts","initializeDefaultStorage","storageObject","localStorage","getItem","name","setItem","value","getPanelGroupKey","autoSaveId","getPanelKey","panels","panel","JSON","stringify","sort","join","loadSerializedPanelGroupState","storage","panelGroupKey","serialized","parsed","parse","savePanelGroupState","panelSizesBeforeCollapse","sizes","_loadSerializedPanelG2","panelKey","expandToSizes","Object","fromEntries","entries","validatePanelGroupLayout","nextLayoutTotalSize","accumulated","remainingSize","defaultStorage","debounceMap","PanelGroupWithForwardedRef","onLayout","panelGroupElementRef","dragState","setDragState","forceUpdate","setCount","prevCount","useForceUpdate","panelIdToLastNotifiedSizeMapRef","panelSizeBeforeCollapseRef","prevDeltaRef","panelDataArrayChanged","didLogIdAndOrderWarning","didLogPanelConstraintsWarning","prevPanelIds","getLayout","unsafeLayout","safeLayout","debouncedSave","callback","durationMs","timeoutId","args","clearTimeout","setTimeout","debounce","clonedPanelDataArray","clonedPanelSizesBeforeCollapse","panelSize","panelDataHelper","findPanelDataIndex","minSizeOverride","minSizeFromProps","prevPanelSize","get","baseSize","precision","flexBasis","flexShrink","overflow","pointerEvents","computePanelFlexBoxStyle","isPanelExpanded","panelA","panelB","orderA","orderB","_loadSerializedPanelG","_state$panelKey","loadPanelGroupState","numPanelsWithSizes","calculateUnsafeDefaultLayout","registerResizeHandle","isRTL","getPropertyValue","layoutChanged","unsafePanelSize","prevCollapsedSize","prevCollapsible","nextCollapsedSize","nextCollapsible","nextMaxSize","nextMinSize","startDragging","stopDragging","flexDirection","Provider","PanelGroup","prevPanelData","PanelResizeHandle","disabled","onBlur","onDragging","onFocus","tabIndex","_hitAreaMargins$coars","_hitAreaMargins$fine","elementRef","callbacksRef","panelGroupContext","registerResizeHandleWithParentGroup","setState","isFocused","setIsFocused","resizeHandler","setResizeHandler","coarseHitAreaMargins","fineHitAreaMargins","_ownerDocumentCounts$","add","_ownerDocumentCounts$2","delete","focus","useWindowSplitterResizeHandlerBehavior","role","touchAction","userSelect"],"mappings":"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","x_google_ignoreList":[0]}