@byeolnaerim/flex-layout 0.0.5 → 0.0.6

package/dist/index.cjs

@@ -1,4 +1,3458 @@
 'use strict';
 
+var React2 = require('react');
+var equal = require('fast-deep-equal');
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React2__default = /*#__PURE__*/_interopDefault(React2);
+var equal__default = /*#__PURE__*/_interopDefault(equal);
+
+// src/flex-layout/components/FlexLayout.tsx
+function updateScrollStore(subject, newValue) {
+  const currentValue = subject.getValue();
+  if (!equal__default.default(currentValue, newValue)) {
+    subject.next(newValue);
+  }
+}
+function updateRefStore(store, newState) {
+  const prevState = store.getValue();
+  if (!equal__default.default(prevState, newState)) {
+    store.next(newState);
+  }
+}
+function updateSplitScreenStore(newValue) {
+  const prevValue = layoutSplitScreenStore.getValue();
+  if (!equal__default.default(prevValue, newValue)) {
+    layoutSplitScreenStore.next(newValue);
+  }
+}
+var scrollPositions = {};
+var scrollPositionsSubject = new rxjs.BehaviorSubject(scrollPositions);
+var setScrollPosition = (layoutName, position) => {
+  const current = scrollPositionsSubject.getValue();
+  const prevPos = current[layoutName];
+  if (prevPos && prevPos.x === position.x && prevPos.y === position.y) {
+    return;
+  }
+  const newPositions = {
+    ...current,
+    [layoutName]: position
+  };
+  updateScrollStore(scrollPositionsSubject, newPositions);
+};
+var getScrollPosition = (layoutName) => {
+  return scrollPositionsSubject.pipe(
+    // 해당 layoutName이 정의되지 않았을 때는 제외
+    operators.filter((e) => e[layoutName] !== void 0),
+    operators.map((positions) => positions[layoutName]),
+    operators.distinctUntilChanged(
+      (prev, curr) => prev?.x === curr?.x && prev?.y === curr?.y
+    )
+  );
+};
+var removeScrollPosition = (layoutName) => {
+  const current = scrollPositionsSubject.getValue();
+  delete current[layoutName];
+  const newPositions = { ...current };
+  updateScrollStore(scrollPositionsSubject, newPositions);
+};
+var layoutSplitScreenStore = new rxjs.BehaviorSubject({});
+var setSplitScreen = (rootName, layoutName, newComponents) => {
+  const current = layoutSplitScreenStore.getValue();
+  const updatedLayout = { ...current[rootName] || {} };
+  updatedLayout[layoutName] = newComponents;
+  const newStoreValue = {
+    ...current,
+    [rootName]: updatedLayout
+  };
+  updateSplitScreenStore(newStoreValue);
+};
+var resetRootSplitScreen = (rootName) => {
+  const current = layoutSplitScreenStore.getValue();
+  const newStoreValue = {
+    ...current,
+    [rootName]: {}
+  };
+  updateSplitScreenStore(newStoreValue);
+};
+var removeSplitScreenChild = (rootName, layoutName) => {
+  const current = layoutSplitScreenStore.getValue();
+  if (!current[rootName]) return;
+  const updatedLayout = { ...current[rootName] };
+  delete updatedLayout[layoutName];
+  const newStoreValue = {
+    ...current,
+    [rootName]: updatedLayout
+  };
+  updateSplitScreenStore(newStoreValue);
+};
+var getCurrentSplitScreenComponents = (rootName, layoutName) => {
+  const current = layoutSplitScreenStore.getValue();
+  if (!current[rootName]) return;
+  return current[rootName][layoutName];
+};
+var getSplitScreen = (rootName, layoutName) => {
+  return layoutSplitScreenStore.pipe(
+    operators.map((splitScreen) => splitScreen[rootName][layoutName]),
+    operators.distinctUntilChanged((prev, curr) => {
+      const filterChildren2 = (obj) => {
+        const { children, component, targetComponent, x, y, ...rest } = obj || {};
+        return rest;
+      };
+      return equal__default.default(filterChildren2(prev), filterChildren2(curr));
+    })
+  );
+};
+var flexContainerStore = new rxjs.BehaviorSubject({});
+var flexResizePanelStore = new rxjs.BehaviorSubject({});
+var setContainerRef = (layoutName, containerName, ref) => {
+  const currentRefs = flexContainerStore.getValue();
+  const updatedLayoutRefs = { ...currentRefs[layoutName] || {} };
+  if (ref === null) {
+    delete updatedLayoutRefs[containerName];
+  } else {
+    updatedLayoutRefs[containerName] = ref;
+  }
+  const newRefs = {
+    ...currentRefs,
+    [layoutName]: updatedLayoutRefs
+  };
+  updateRefStore(flexContainerStore, newRefs);
+};
+var setResizePanelRef = (layoutName, containerName, ref) => {
+  const currentRefs = flexResizePanelStore.getValue();
+  const updatedLayoutRefs = { ...currentRefs[layoutName] || {} };
+  if (ref === null) {
+    delete updatedLayoutRefs[containerName];
+  } else {
+    updatedLayoutRefs[containerName] = ref;
+  }
+  const newRefs = {
+    ...currentRefs,
+    [layoutName]: updatedLayoutRefs
+  };
+  updateRefStore(flexResizePanelStore, newRefs);
+};
+var getLayoutInfos = (layoutName) => {
+  return rxjs.combineLatest([flexContainerStore, flexResizePanelStore]).pipe(
+    operators.map(([containerRefs, resizePanelRefs]) => {
+      const containerData = containerRefs[layoutName] || {};
+      const resizePanelData = resizePanelRefs[layoutName] || {};
+      return {
+        container: containerData,
+        resizePanel: resizePanelData
+      };
+    }),
+    operators.filter((result) => result.container !== null)
+    // 빈 객체 제외
+  );
+};
+var getContainerRef = ({
+  containerName,
+  layoutName
+}) => {
+  return flexContainerStore.pipe(
+    operators.map((refs) => {
+      if (layoutName) {
+        return refs[layoutName]?.[containerName] || null;
+      } else {
+        return Object.entries(refs).find(
+          ([key, value]) => refs[key][containerName]
+        )?.[1][containerName];
+      }
+    }),
+    operators.filter((ref) => ref !== null)
+  );
+};
+var getResizePanelRef = ({
+  containerName,
+  layoutName
+}) => {
+  return flexResizePanelStore.pipe(
+    operators.map((refs) => {
+      if (layoutName) {
+        return refs[layoutName]?.[containerName] || null;
+      } else {
+        return Object.entries(refs).find(
+          ([key, value]) => refs[key][containerName]
+        )?.[1][containerName];
+      }
+    }),
+    operators.filter((ref) => ref !== null)
+  );
+};
+
+// src/flex-layout/utils/FlexLayoutUtils.ts
+function isDocumentOut({ x, y }) {
+  if (typeof window == "undefined") return;
+  const { innerWidth, innerHeight, scrollX, scrollY } = window;
+  return x < 0 || y < 0 || x > innerWidth + scrollX || y > innerHeight + scrollY;
+}
+var lastTouchEvent;
+function getClientXy(event) {
+  let clientX;
+  let clientY;
+  if (window.MouseEvent && event instanceof window.MouseEvent) {
+    clientX = event.clientX;
+    clientY = event.clientY;
+  } else if (window.TouchEvent && event instanceof window.TouchEvent) {
+    const _event = event.touches.length == 0 ? lastTouchEvent : event;
+    clientX = _event.touches[0].clientX;
+    clientY = _event.touches[0].clientY;
+    lastTouchEvent = event;
+  } else {
+    return;
+  }
+  return { clientX, clientY };
+}
+function isOverMove(elementSize, elementMinSize) {
+  return Math.floor(elementSize) <= 0 || (isNaN(elementMinSize) ? false : elementMinSize >= Math.floor(elementSize));
+}
+function findNotCloseFlexContent(target, direction) {
+  if (!target) return target;
+  let _target = target;
+  const isCloseCheck = () => {
+    let grow = parseFloat(window.getComputedStyle(_target).flex.split(" ")[0]) || 0;
+    if (grow == 0) {
+      return true;
+    } else {
+      return false;
+    }
+  };
+  while (isCloseCheck()) {
+    let nextTarget = _target[direction]?.[direction];
+    _target = nextTarget;
+    if (!_target) {
+      break;
+    }
+  }
+  return _target;
+}
+function remain(flexContainerList) {
+  return new Promise((resolve) => {
+    let notGrowList = [];
+    let totalGrow = flexContainerList.reduce((t, e, i) => {
+      if (e.hasAttribute("data-grow") == false) {
+        notGrowList.push(e);
+        return t;
+      }
+      let grow = parseFloat(e.dataset.grow || "");
+      e.style.flex = `${grow} 1 0%`;
+      t -= grow;
+      return t;
+    }, flexContainerList.length);
+    if (notGrowList.length != 0) {
+      resize(notGrowList, totalGrow);
+    }
+    resolve(flexContainerList);
+  });
+}
+function resize(list, totalGrow) {
+  return new Promise((resolve) => {
+    let resizeWeight = totalGrow / list.length;
+    list.forEach((e) => {
+      e.dataset.grow = resizeWeight.toString();
+      e.style.flex = `${resizeWeight} 1 0%`;
+    });
+    resolve(resizeWeight);
+  });
+}
+function mathWeight(totalCount, totalGrow) {
+  return 1 + (totalGrow - totalCount) / totalCount;
+}
+function mathGrow(childSize, parentSize, containerCount) {
+  return containerCount * (childSize / parentSize);
+}
+function getGrow(growTarget) {
+  const target = growTarget instanceof Element ? growTarget : growTarget;
+  return parseFloat(target.style.flex.split(" ")[0]) || parseFloat(target.dataset.grow || "");
+}
+function closeFlex(resizeTarget, containers, {
+  isResize = false,
+  isDsiabledResizePanel = false,
+  sizeName
+}) {
+  return new Promise((resolve) => {
+    if (!resizeTarget.hasAttribute("data-is_resize_panel")) ; else if (isDsiabledResizePanel) {
+      resizeTarget.dataset.is_resize_panel = "false";
+    }
+    resizeTarget.dataset.prev_grow = getGrow(resizeTarget).toString();
+    let notCloseList = containers.filter(
+      (e) => e.style.flex != "0 1 0%" && e != resizeTarget
+    );
+    let notCloseAndOpenTargetList = [...notCloseList, resizeTarget];
+    notCloseAndOpenTargetList.forEach((e) => {
+      e.style.transition = "flex 0.5s";
+      e.ontransitionend = (event) => {
+        if (event.propertyName != "flex-grow") {
+          return;
+        }
+        notCloseAndOpenTargetList.forEach(
+          (e2) => e2.style.transition = ""
+        );
+        e.ontransitionend = () => {
+        };
+      };
+      if (e == resizeTarget) {
+        e.dataset.grow = "0";
+        e.style.flex = `0 1 0%`;
+        return;
+      }
+      if (isResize) {
+        return;
+      }
+      let percent = getGrow(e) / containers.length;
+      if (notCloseList.length == 1) {
+        e.dataset.grow = containers.length.toString();
+        e.style.flex = `${containers.length} 1 0%`;
+        return;
+      }
+      e.dataset.grow = (containers.length * percent).toString();
+      e.style.flex = `${containers.length * percent} 1 0%`;
+    });
+    if (isResize) {
+      resize(notCloseList, containers.length);
+    }
+    resolve(resizeTarget);
+  });
+}
+function openFlex(resizeTarget, containers, {
+  isPrevSizeOpen = false,
+  isResize = false,
+  openGrowImportant = 0,
+  sizeName
+}) {
+  return new Promise((resolve) => {
+    if (!resizeTarget.hasAttribute("data-is_resize_panel")) ; else if (resizeTarget.hasAttribute("data-is_resize_panel") && resizeTarget.dataset.is_resize_panel == "false") {
+      resizeTarget.dataset.is_resize_panel = "true";
+    }
+    let notCloseList = containers.filter(
+      (e) => e.style.flex != "0 1 0%" && e != resizeTarget
+    );
+    let notCloseAndOpenTargetList = [...notCloseList, resizeTarget];
+    let openTargetGrow = 1;
+    const sizeStyleName = "client" + sizeName.charAt(0).toUpperCase() + sizeName.substring(1);
+    const parentSize = sizeName && resizeTarget.parentElement && resizeTarget.parentElement[sizeStyleName] || 0;
+    if (isPrevSizeOpen && resizeTarget.hasAttribute("data-prev_grow")) {
+      openTargetGrow = parseFloat(resizeTarget.dataset.prev_grow || "1") || 1;
+    } else if (parentSize && parentSize !== 0) {
+      openTargetGrow = parentSize / notCloseList.length / (parentSize - 1) * containers.length;
+    } else {
+      openTargetGrow = 1;
+    }
+    if (openGrowImportant) {
+      openTargetGrow = openGrowImportant;
+    }
+    openTargetGrow = openTargetGrow === Infinity ? 1 : openTargetGrow;
+    notCloseAndOpenTargetList.forEach((e) => {
+      e.style.transition = "flex 0.5s";
+      e.ontransitionend = (event) => {
+        if (event.propertyName != "flex-grow") {
+          return;
+        }
+        notCloseAndOpenTargetList.forEach(
+          (e2) => e2.style.transition = ""
+        );
+        e.ontransitionend = () => {
+        };
+      };
+      if (e == resizeTarget) {
+        resizeTarget.dataset.grow = openTargetGrow.toString();
+        resizeTarget.style.flex = `${openTargetGrow} 1 0%`;
+        return;
+      }
+      if (isResize) {
+        return;
+      }
+      let grow = parentSize / notCloseList.length / (parentSize - 1) * (containers.length - openTargetGrow);
+      grow = grow === Infinity ? 1 : grow;
+      e.dataset.grow = grow.toString();
+      e.style.flex = `${grow} 1 0%`;
+    });
+    if (isResize) {
+      resize(notCloseAndOpenTargetList, containers.length);
+    }
+    resolve(openTargetGrow);
+  });
+}
+var g = globalThis;
+g.__FLEX_SUBJECTS__ ?? (g.__FLEX_SUBJECTS__ = { openClose: {}, spread: {} });
+var containerOpenCloseSubjectMap = g.__FLEX_SUBJECTS__.openClose;
+var containerSpreadSubjectMap = g.__FLEX_SUBJECTS__.spread;
+var ContainerOpenCloseProvider = ({
+  layoutName,
+  containerName,
+  sizeName
+}) => {
+  if (!containerOpenCloseSubjectMap[containerName]) {
+    containerOpenCloseSubjectMap[containerName] = new rxjs.Subject();
+  }
+  if (!containerSpreadSubjectMap[containerName]) {
+    containerSpreadSubjectMap[containerName] = new rxjs.Subject();
+  }
+  const [containers, setContainers] = React2.useState([]);
+  const [container, setContainer] = React2.useState();
+  React2.useEffect(() => {
+    const subscription = getLayoutInfos(layoutName).subscribe(
+      (layout) => {
+        if (!layout || !layout.container[containerName] || !layout.container[containerName].current)
+          return;
+        setContainers(
+          Object.values(layout.container).filter(
+            (e) => e.current !== null
+          ).map((e) => e.current)
+        );
+        setContainer(layout.container[containerName].current);
+      }
+    );
+    return () => subscription.unsubscribe();
+  }, [containerName, layoutName]);
+  React2.useEffect(() => {
+    const styleName = `${sizeName.charAt(0).toUpperCase() + sizeName.substring(1)}`;
+    const clientSize = "client" + styleName;
+    const outerSize = "outer" + styleName;
+    const maxSize = "max" + styleName;
+    const subscribe = containerOpenCloseSubjectMap[containerName].subscribe(
+      ({
+        mode,
+        initOpenState: isOpenState,
+        onClose,
+        onOpen,
+        openOption = {},
+        closeOption = {}
+      }) => {
+        if (!container || containers.length === 0) return;
+        const currentGrow = getGrow(container);
+        const styleMap = window.getComputedStyle(container);
+        const maxSizeGrow = mathGrow(
+          parseInt(styleMap[maxSize]),
+          container.parentElement && container.parentElement[clientSize] || window[outerSize],
+          containers.length
+        );
+        const open = () => openFlex(container, containers, {
+          sizeName,
+          ...isNaN(maxSizeGrow) ? {} : {
+            openGrowImportant: maxSizeGrow
+          },
+          ...openOption
+        }).then((openTargetGrow) => {
+          if (onOpen) onOpen();
+          containerSpreadSubjectMap[containerName].next({
+            isOpen: true,
+            grow: openTargetGrow,
+            targetContainer: container
+          });
+        });
+        const close = () => closeFlex(container, containers, {
+          sizeName,
+          ...closeOption
+        }).then(() => {
+          if (onClose) onClose();
+          containerSpreadSubjectMap[containerName].next({
+            isOpen: false,
+            grow: 0,
+            targetContainer: container
+          });
+        });
+        if (mode === "toggle") {
+          if (currentGrow === 0) {
+            open();
+          } else {
+            close();
+          }
+        } else if (mode === "open") {
+          if (currentGrow === 0) {
+            open();
+          }
+        } else if (mode === "close") {
+          if (currentGrow !== 0) {
+            close();
+          }
+        }
+      }
+    );
+    return () => {
+      subscribe.unsubscribe();
+    };
+  }, [containerName, container, containers, sizeName]);
+  return null;
+};
+var useContainers = (layoutName) => {
+  const [containers, setContainers] = React2.useState([]);
+  React2.useEffect(() => {
+    const subscription = getLayoutInfos(layoutName).subscribe(
+      (layout) => {
+        setContainers(
+          Object.values(layout.container).filter(
+            (e) => e.current !== null
+          ).map((e) => e.current)
+        );
+      }
+    );
+    return () => subscription.unsubscribe();
+  }, [layoutName]);
+  return containers;
+};
+var useLayoutName = (containerName) => {
+  const [layoutName, setLayoutName] = React2.useState();
+  React2.useEffect(() => {
+    const subscribe = flexContainerStore.pipe(
+      rxjs.map(
+        (layouts) => Object.entries(layouts).filter(([_, v]) => v[containerName]).map(([k]) => k)[0]
+        // 첫 번째 결과 가져오기
+      )
+    ).subscribe(setLayoutName);
+    return () => subscribe.unsubscribe();
+  }, [containerName]);
+  return layoutName;
+};
+var useDecompositionLayout = ({
+  layoutName: initialLayoutName,
+  containerName
+}) => {
+  const derivedLayoutName = useLayoutName(containerName);
+  const finalLayoutName = initialLayoutName || derivedLayoutName;
+  const [containers, setContainers] = React2.useState([]);
+  const [container, setContainer] = React2.useState();
+  const [resizePanel, setResizePanel] = React2.useState();
+  React2.useEffect(() => {
+    if (!finalLayoutName) return;
+    const subscription = getLayoutInfos(finalLayoutName).subscribe(
+      (layout) => {
+        if (!layout) return;
+        setContainers(
+          Object.values(layout.container).filter(
+            (e) => e.current !== null
+          ).map((e) => e.current)
+        );
+        if (containerName && layout.container[containerName] && layout.container[containerName].current) {
+          setContainer(layout.container[containerName].current);
+          if (layout.resizePanel[containerName] && layout.resizePanel[containerName].current) {
+            setResizePanel(
+              layout.resizePanel[containerName].current
+            );
+          }
+        }
+      }
+    );
+    return () => subscription.unsubscribe();
+  }, [containerName, finalLayoutName]);
+  return { layout: containers, container, resizePanel };
+};
+var useContainerSize = (containerName) => {
+  const { layout, container, resizePanel } = useDecompositionLayout({
+    containerName
+  });
+  const [size, setSize] = React2.useState();
+  React2.useEffect(() => {
+    if (!container) return;
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        setSize({
+          width: entry.contentRect.width,
+          height: entry.contentRect.height
+        });
+      }
+    });
+    observer.observe(container);
+    return () => observer.disconnect();
+  }, [container]);
+  return { size };
+};
+var useDoubleClick = (containerName, opt) => {
+  const [isOpen, setIsOpen] = React2.useState();
+  const [isDoubleClick, setIsDoubleClick] = React2.useState();
+  React2.useEffect(() => {
+    const resizePanelClickEvent = getResizePanelRef({
+      containerName
+    }).pipe(
+      rxjs.filter(
+        (resizePanelref) => resizePanelref != void 0 && resizePanelref.current != void 0
+      ),
+      //take(1),
+      rxjs.switchMap((resizePanelref) => {
+        if (!resizePanelref || !resizePanelref.current) return rxjs.EMPTY;
+        return rxjs.fromEvent(resizePanelref.current, "click");
+      })
+    );
+    const subscribe = resizePanelClickEvent.pipe(
+      rxjs.buffer(resizePanelClickEvent.pipe(rxjs.debounceTime(500))),
+      rxjs.filter((clickEventArray) => clickEventArray.length >= 2),
+      rxjs.map((events) => {
+        containerOpenCloseSubjectMap[containerName].next({
+          ...opt,
+          openOption: {
+            ...opt.openOption,
+            isPrevSizeOpen: false
+          },
+          onClose: () => {
+            if (opt.onClose) opt.onClose();
+            setIsOpen(false);
+            setIsDoubleClick(true);
+          },
+          onOpen: () => {
+            if (opt.onOpen) opt.onOpen();
+            setIsOpen(true);
+            setIsDoubleClick(true);
+          }
+        });
+      })
+    ).subscribe();
+    return () => {
+      subscribe.unsubscribe();
+    };
+  }, [containerName]);
+  return { isOpen, isDoubleClick, setIsDoubleClick };
+};
+
+// src/flex-layout/styles/FlexLayout.module.css
+var FlexLayout_default = {};
+var FlexLayoutContext = React2.createContext(null);
+function useFlexLayoutContext() {
+  const context = React2.useContext(FlexLayoutContext);
+  if (!context) {
+    throw new Error(
+      "useFlexLayoutContext must be used within FlexLayoutContext.Provider"
+    );
+  }
+  return context;
+}
+function FlexLayoutProvider({
+  value,
+  children
+}) {
+  return /* @__PURE__ */ React.createElement(FlexLayoutContext.Provider, { value }, children);
+}
+
+// src/flex-layout/components/FlexLayout.tsx
+function FlexLayout({
+  layoutName,
+  direction,
+  children,
+  ref,
+  className,
+  panelClassName,
+  panelMovementMode = "divorce",
+  ...props
+}) {
+  const containerCount = React2.Children.count(children);
+  const fitContent = direction === "row" ? "width" : "height";
+  const isFragmentElement = (node) => React2.isValidElement(node) && node.type === React2.Fragment;
+  const nodes = React2.Children.toArray(children).flatMap(
+    (node) => isFragmentElement(node) ? React2.Children.toArray(node.props.children) : [node]
+  );
+  const flattenedChildren = nodes.filter(
+    React2.isValidElement
+  );
+  if (flattenedChildren.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    FlexLayoutProvider,
+    {
+      value: {
+        layoutName,
+        direction,
+        panelMovementMode,
+        panelClassName,
+        containerCount,
+        fitContent
+      }
+    },
+    /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        className: `${FlexLayout_default["flex-layout"]} ${className && className !== "" ? className : ""}`,
+        ...ref ? { ref } : {},
+        ...props,
+        "data-layout_name": layoutName,
+        "data-direction": direction
+      },
+      flattenedChildren.map((child, index) => {
+        if (!child || !React2.isValidElement(child)) return null;
+        return /* @__PURE__ */ React.createElement(React2.Fragment, { key: index }, child, /* @__PURE__ */ React.createElement(
+          ContainerOpenCloseProvider,
+          {
+            layoutName,
+            containerName: child.props.containerName,
+            sizeName: fitContent
+          }
+        ));
+      })
+    )
+  ));
+}
+var useSize = (sizeName) => {
+  const ref = React2.useRef(null);
+  const [size, setSize] = React2.useState(void 0);
+  React2.useLayoutEffect(() => {
+    if (!ref.current) return;
+    const handleResize = () => {
+      if (ref.current) {
+        const newSize = ref.current.getBoundingClientRect()[sizeName];
+        setSize(newSize);
+      }
+    };
+    handleResize();
+    const resizeObserver = new ResizeObserver(() => {
+      handleResize();
+    });
+    resizeObserver.observe(ref.current);
+    window.addEventListener("resize", handleResize);
+    return () => {
+      resizeObserver.disconnect();
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [sizeName]);
+  return { ref, size };
+};
+var flexDirectionModel = {
+  row: {
+    xy: "x",
+    targetDirection: "left",
+    nextDirection: "right",
+    sizeName: "width",
+    resizeCursor: "ew-resize"
+  },
+  column: {
+    xy: "y",
+    targetDirection: "top",
+    nextDirection: "bottom",
+    sizeName: "height",
+    resizeCursor: "ns-resize"
+  }
+};
+function FlexLayoutResizePanel({
+  direction,
+  containerCount,
+  panelMode = "default",
+  containerName,
+  layoutName,
+  panelClassName,
+  panelMovementMode
+}) {
+  let isResizePanelClickRef = React2.useRef(false);
+  let prevTouchEvent = null;
+  let parentSizeRef = React2.useRef(0);
+  let totalMovementRef = React2.useRef(0);
+  const containerCountRef = React2.useRef(containerCount);
+  React2.useEffect(() => {
+    return () => {
+      document.body.style.cursor = "";
+    };
+  }, []);
+  React2.useEffect(() => {
+    containerCountRef.current = containerCount;
+  }, [containerCount]);
+  const panelRef = React2.useRef(null);
+  const panelMouseDownEvent = (event) => {
+    if (!panelRef.current || !panelRef.current.parentElement) return;
+    isResizePanelClickRef.current = true;
+    containerCountRef.current = [
+      ...panelRef.current.parentElement.children
+    ].filter((e) => e.hasAttribute("data-container_name")).length;
+    const sizeName = flexDirectionModel[direction].sizeName;
+    parentSizeRef.current = panelRef.current.parentElement.getBoundingClientRect()[sizeName];
+    prevTouchEvent = null;
+    totalMovementRef.current = 0;
+    if (!parentSizeRef.current) return;
+    document.body.style.cursor = flexDirectionModel[direction].resizeCursor;
+  };
+  const panelMouseUpEvent = () => {
+    isResizePanelClickRef.current = false;
+    parentSizeRef.current = 0;
+    prevTouchEvent = null;
+    totalMovementRef.current = 0;
+    document.body.style.cursor = "";
+  };
+  function moveMouseFlex(originTarget, resizePanel, moveEvent) {
+    const model = flexDirectionModel[direction];
+    const movement = moveEvent["movement" + model.xy.toUpperCase()];
+    totalMovementRef.current += movement;
+    const minSizeName = "min-" + model.sizeName;
+    const maxSizeName = "max-" + model.sizeName;
+    let targetElement = findNotCloseFlexContent(
+      originTarget,
+      "previousElementSibling"
+    );
+    if (panelMovementMode === "divorce" && totalMovementRef.current > 0 || panelMovementMode === "bulldozer" && movement > 0 || !targetElement)
+      targetElement = originTarget;
+    let nextElement = findNotCloseFlexContent(
+      resizePanel.nextElementSibling,
+      "nextElementSibling"
+    );
+    if (panelMovementMode === "divorce" && totalMovementRef.current < 0 || panelMovementMode === "bulldozer" && movement < 0 || !nextElement)
+      nextElement = resizePanel.nextElementSibling;
+    if (!targetElement || !nextElement) return;
+    const targetRect = targetElement.getBoundingClientRect();
+    const targetStyle = window.getComputedStyle(targetElement);
+    const targetMinSize = parseFloat(targetStyle.getPropertyValue(minSizeName)) || 0;
+    const targetMaxSize = parseFloat(targetStyle.getPropertyValue(maxSizeName)) || 0;
+    const nextRect = nextElement.getBoundingClientRect();
+    const nextStyle = window.getComputedStyle(nextElement);
+    const nextMinSize = parseFloat(nextStyle.getPropertyValue(minSizeName)) || 0;
+    const nextMaxSize = parseFloat(nextStyle.getPropertyValue(maxSizeName)) || 0;
+    let targetSize = targetRect[model.sizeName] + movement;
+    let nextElementSize = nextRect[model.sizeName] - movement;
+    if (targetMaxSize > 0 && targetSize > targetMaxSize) {
+      return;
+    }
+    if (nextMaxSize > 0 && nextElementSize > nextMaxSize) {
+      return;
+    }
+    if (isOverMove(targetSize, targetMinSize)) {
+      targetSize = 0;
+      nextElementSize = nextRect[model.sizeName];
+    } else if (isOverMove(nextElementSize, nextMinSize)) {
+      nextElementSize = 0;
+      targetSize = targetRect[model.sizeName];
+    }
+    const targetFlexGrow = targetSize / (parentSizeRef.current - 1) * containerCountRef.current;
+    const nextElementFlexGrow = nextElementSize / (parentSizeRef.current - 1) * containerCountRef.current;
+    if (!(targetElement instanceof HTMLElement)) return;
+    if (!(nextElement instanceof HTMLElement)) return;
+    targetElement.style.flex = `${targetFlexGrow} 1 0%`;
+    nextElement.style.flex = `${nextElementFlexGrow} 1 0%`;
+  }
+  React2.useEffect(() => {
+    const addGlobalMoveEvent = (event) => {
+      if (!isResizePanelClickRef.current || !panelRef.current) {
+        return;
+      }
+      event.preventDefault();
+      const targetElement = panelRef.current.previousElementSibling;
+      const targetPanel = panelRef.current;
+      if (!targetElement || !targetPanel) return;
+      let move = { movementX: 0, movementY: 0 };
+      if (window.TouchEvent && event instanceof window.TouchEvent) {
+        if (!prevTouchEvent) {
+          prevTouchEvent = event;
+          return;
+        }
+        move.movementX = (prevTouchEvent.touches[0].pageX - event.touches[0].pageX) * -2;
+        move.movementY = (prevTouchEvent.touches[0].pageY - event.touches[0].pageY) * -2;
+        prevTouchEvent = event;
+      } else {
+        move.movementX = event.movementX;
+        move.movementY = event.movementY;
+      }
+      moveMouseFlex(targetElement, targetPanel, move);
+    };
+    ["mousemove", "touchmove"].forEach((eventName) => {
+      window.addEventListener(eventName, addGlobalMoveEvent, {
+        passive: false
+      });
+    });
+    ["mouseup", "touchend"].forEach((eventName) => {
+      window.addEventListener(eventName, panelMouseUpEvent);
+    });
+    return () => {
+      ["mousemove", "touchmove"].forEach((eventName) => {
+        window.removeEventListener(eventName, addGlobalMoveEvent);
+      });
+      ["mouseup", "touchend"].forEach((eventName) => {
+        window.removeEventListener(eventName, panelMouseUpEvent);
+      });
+    };
+  }, []);
+  React2.useEffect(() => {
+    if (!panelRef.current) return;
+    setResizePanelRef(layoutName, containerName, panelRef);
+  }, [containerName, layoutName]);
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      id: containerName + "_resize_panel",
+      className: `${FlexLayout_default["flex-resize-panel"]} ${FlexLayout_default[panelMode]} ${panelClassName && panelClassName !== "" ? panelClassName : ""}`,
+      ref: panelRef,
+      onMouseDown: panelMouseDownEvent,
+      onTouchStart: panelMouseDownEvent
+    },
+    /* @__PURE__ */ React.createElement("div", { className: FlexLayout_default.hover })
+  );
+}
+
+// src/flex-layout/components/FlexLayoutContainer.tsx
+function FlexLayoutContainer({
+  isFitContent,
+  isFitResize,
+  // fitContent,
+  // containerCount,
+  // layoutName,
+  containerName,
+  grow: initialGrow,
+  prevGrow: initialPrevGrow,
+  isInitialResizable,
+  isResizePanel,
+  children,
+  className,
+  panelMode
+}) {
+  const {
+    direction,
+    panelMovementMode,
+    panelClassName,
+    layoutName,
+    fitContent,
+    containerCount
+  } = useFlexLayoutContext();
+  const { ref, size } = (
+    // isFitContent && fitContent
+    //?
+    useSize(fitContent)
+  );
+  const flexContainerNodeRef = React2.useRef(null);
+  const flexContainerRef = React2.useCallback(
+    (node) => {
+      flexContainerNodeRef.current = node;
+      if (node !== null) {
+        setContainerRef(layoutName, containerName, { current: node });
+      }
+    },
+    [layoutName, containerName]
+  );
+  const [growState, setGrowState] = React2.useState(initialGrow);
+  React2.useEffect(() => {
+    setGrowState(initialGrow);
+  }, [initialGrow]);
+  const [prevGrowState, setPrevGrowState] = React2.useState(
+    initialPrevGrow
+  );
+  const [isFirstLoad, setIsFirstLoad] = React2.useState(true);
+  React2.useEffect(() => {
+    if (!flexContainerNodeRef.current) return;
+    setContainerRef(layoutName, containerName, flexContainerNodeRef);
+    return () => {
+      setContainerRef(layoutName, containerName, {
+        current: null
+      });
+    };
+  }, [containerName, layoutName]);
+  React2.useEffect(() => {
+    if (typeof window == "undefined" || flexContainerNodeRef.current === null)
+      return;
+    const storedGrow = sessionStorage.getItem(containerName);
+    if (storedGrow !== null) {
+      const parsed = parseFloat(storedGrow);
+      if (!isNaN(parsed)) {
+        flexContainerNodeRef.current.style.flex = `${parsed} 1 0%`;
+        setGrowState(parsed);
+      }
+    }
+  }, [containerName]);
+  React2.useEffect(() => {
+    if (!flexContainerNodeRef.current) return;
+    const targetNode = flexContainerNodeRef.current;
+    const observer = new MutationObserver((mutations) => {
+      for (const mutation of mutations) {
+        if (mutation.type === "attributes" && mutation.attributeName === "style" && targetNode.style.flex) {
+          const flexValue = targetNode.style.flex;
+          const parsedGrow = parseFloat(flexValue.split(" ")[0]);
+          if (!isNaN(parsedGrow)) {
+            setGrowState(parsedGrow);
+          }
+        }
+      }
+    });
+    observer.observe(targetNode, {
+      attributes: true,
+      attributeFilter: ["style"],
+      attributeOldValue: true
+    });
+    return () => {
+      observer.disconnect();
+    };
+  }, [containerName]);
+  React2.useEffect(() => {
+    if (!flexContainerNodeRef.current || !ref || !ref.current || !size || !fitContent)
+      return;
+    requestAnimationFrame(() => {
+      if (!flexContainerNodeRef.current) return;
+      const sizeName = `${fitContent.charAt(0).toUpperCase() + fitContent.substring(1)}`;
+      const parentSize = flexContainerNodeRef.current.parentElement && flexContainerNodeRef.current.parentElement["client" + sizeName] || 0;
+      if (isFitContent) {
+        flexContainerNodeRef.current.style["max" + sizeName] = size + "px";
+      }
+      if (!isFitResize && isFirstLoad) {
+        setIsFirstLoad(false);
+        return;
+      }
+      if (getGrow(flexContainerNodeRef.current) != 0 && isFitResize) {
+        const newGrow = mathGrow(size, parentSize, containerCount);
+        setPrevGrowState(growState);
+        setGrowState(newGrow);
+      }
+    });
+  }, [size, containerCount, isFitResize, children]);
+  React2.useEffect(() => {
+    if (!flexContainerNodeRef.current) return;
+    let notGrowList = [];
+    let containerList = [
+      ...flexContainerNodeRef.current.parentElement?.children || []
+    ].filter((e) => e.hasAttribute("data-container_name"));
+    let remainingGrow = containerList.reduce((t, e, i) => {
+      let item = e;
+      if (item.classList.contains(FlexLayout_default["flex-resize-panel"])) return t;
+      if (e.hasAttribute("data-grow") == false || e.getAttribute("data-is_resize") === "true") {
+        notGrowList.push(item);
+        return t;
+      }
+      let grow = parseFloat(item.dataset.grow || "");
+      item.style.flex = `${grow} 1 0%`;
+      t -= grow;
+      return t;
+    }, containerList.length);
+    if (notGrowList.length != 0) {
+      let resizeWeight = mathWeight(notGrowList.length, remainingGrow);
+      notGrowList.forEach((e) => {
+        e.dataset.grow = resizeWeight.toString();
+        e.style.flex = `${resizeWeight} 1 0%`;
+      });
+    }
+  }, []);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      id: containerName,
+      "data-container_name": containerName,
+      ref: flexContainerRef,
+      className: `${FlexLayout_default["flex-container"]} ${className && className !== "" ? className : ""}`,
+      ...growState !== void 0 ? { ["data-grow"]: growState } : {},
+      ...prevGrowState != void 0 ? { ["data-prev_grow"]: prevGrowState } : {},
+      "data-is_resize": isInitialResizable,
+      "data-is_resize_panel": isResizePanel,
+      style: growState !== void 0 && {
+        flex: `${growState} 1 0%`
+      } || {}
+    },
+    isFitContent && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        className: `${FlexLayout_default["flex-content-fit-wrapper"]}`,
+        ref
+      },
+      children
+    ) || children
+  ), isResizePanel && /* @__PURE__ */ React.createElement(
+    FlexLayoutResizePanel,
+    {
+      containerName,
+      layoutName,
+      direction,
+      containerCount,
+      panelMode,
+      panelClassName,
+      panelMovementMode
+    }
+  ));
+}
+var dragState = new rxjs.Subject();
+var filterChildren = (obj) => {
+  const { children, ...rest } = obj || {};
+  return rest;
+};
+var useDragCapture = (targetRef) => {
+  const stateRef = React2.useRef(null);
+  const forceUpdate = React2.useRef(0);
+  React2.useEffect(() => {
+    const subscription = dragState.pipe(
+      rxjs.map((value) => {
+        if (!targetRef || !targetRef.current) return null;
+        const { x, y } = value;
+        const rect = targetRef.current.getBoundingClientRect();
+        const {
+          width,
+          height,
+          x: rectX,
+          y: rectY,
+          right,
+          bottom
+        } = rect;
+        let isOver = false;
+        if (x < rectX || x > right || y < rectY || y > bottom) {
+          isOver = true;
+        }
+        const leftBoundary = rectX + width * 0.2;
+        const rightBoundary = right - width * 0.2;
+        const topBoundary = rectY + height * 0.2;
+        const bottomBoundary = bottom - height * 0.2;
+        let position = "centerBoundary";
+        if (x < leftBoundary) {
+          position = "leftBoundary";
+        } else if (x > rightBoundary) {
+          position = "rightBoundary";
+        } else if (y < topBoundary) {
+          position = "topBoundary";
+        } else if (y > bottomBoundary) {
+          position = "bottomBoundary";
+        }
+        return {
+          positionName: position,
+          isOver,
+          ...value
+        };
+      }),
+      rxjs.distinctUntilChanged(
+        (prev, curr) => equal__default.default(filterChildren(prev), filterChildren(curr))
+      )
+    ).subscribe({
+      next: (value) => {
+        if (value && !equal__default.default(
+          filterChildren(stateRef.current),
+          filterChildren(value)
+        )) {
+          stateRef.current = value;
+          forceUpdate.current++;
+        }
+      },
+      error: (err) => console.error(err)
+    });
+    return () => subscription.unsubscribe();
+  }, [targetRef]);
+  const [, rerender] = React2.useState({});
+  React2.useEffect(() => {
+    const interval = setInterval(() => {
+      rerender({});
+    }, 50);
+    return () => clearInterval(interval);
+  }, []);
+  return stateRef.current;
+};
+var dropMovementEventSubject = new rxjs.Subject();
+var allSplitScreenCount = new rxjs.BehaviorSubject(0);
+var useDragEvents = ({
+  isBlockingActiveInput = false
+}) => {
+  const dragResumeTimer = React2.useRef(null);
+  const scrollThreshold = 10;
+  const isScrolling = React2.useRef(false);
+  const isPending = React2.useRef(false);
+  const isMouseDown = React2.useRef(false);
+  const isDragging = React2.useRef(false);
+  const touchStartX = React2.useRef(0);
+  const touchStartY = React2.useRef(0);
+  const handleStart = React2.useCallback(
+    ({
+      event: _event,
+      dragStartCallback
+    }) => {
+      const event = _event instanceof Event ? _event : _event.nativeEvent;
+      if (dragResumeTimer.current) {
+        clearTimeout(dragResumeTimer.current);
+        dragResumeTimer.current = null;
+      }
+      if (event.target.contentEditable === "true" || isBlockingActiveInput && document.activeElement === event.target) {
+        return;
+      }
+      if (event.cancelable) {
+        event.preventDefault();
+      }
+      isPending.current = true;
+      isMouseDown.current = true;
+      if (event instanceof globalThis.TouchEvent) {
+        const touch = event.touches[0];
+        touchStartX.current = touch.clientX;
+        touchStartY.current = touch.clientY;
+      } else if (event instanceof globalThis.MouseEvent) {
+        touchStartX.current = event.clientX;
+        touchStartY.current = event.clientY;
+      }
+      setTimeout(() => {
+        if (!isPending.current || isScrolling.current) return;
+        isPending.current = false;
+        isDragging.current = true;
+        const xy = getClientXy(event);
+        if (!xy) return;
+        const { clientX, clientY } = xy;
+        dragStartCallback({ x: clientX, y: clientY });
+      }, 300);
+    },
+    [isBlockingActiveInput]
+  );
+  const handleMove = React2.useCallback(
+    ({
+      event: _event,
+      notDragCallback,
+      dragStartCallback,
+      moveingCallback
+    }) => {
+      if (!isMouseDown.current) return;
+      const event = _event instanceof Event ? _event : _event.nativeEvent;
+      const xy = getClientXy(event);
+      if (!xy) return;
+      const { clientX, clientY } = xy;
+      const deltaX = Math.abs(clientX - touchStartX.current);
+      const deltaY = Math.abs(clientY - touchStartY.current);
+      if (isPending.current && (deltaX > scrollThreshold || deltaY > scrollThreshold)) {
+        isScrolling.current = true;
+        isPending.current = false;
+        isDragging.current = false;
+        if (notDragCallback)
+          notDragCallback({ x: clientX, y: clientY });
+        if (dragResumeTimer.current) {
+          clearTimeout(dragResumeTimer.current);
+          dragResumeTimer.current = null;
+        }
+        dragResumeTimer.current = setTimeout(() => {
+          if (!isMouseDown.current) return;
+          if (dragStartCallback)
+            dragStartCallback({ x: clientX, y: clientY });
+          isPending.current = true;
+          isScrolling.current = false;
+          handleStart({ event: _event, dragStartCallback });
+        }, 400);
+        return;
+      }
+      if (!isDragging.current || isPending.current) return;
+      moveingCallback({ x: clientX, y: clientY });
+    },
+    [isBlockingActiveInput]
+  );
+  const handleEnd = React2.useCallback(
+    ({
+      event: _event,
+      dragEndCallback
+    }) => {
+      isScrolling.current = false;
+      isMouseDown.current = false;
+      if (isPending.current) {
+        isPending.current = false;
+        return;
+      }
+      const event = _event instanceof Event ? _event : _event.nativeEvent;
+      if (!isDragging.current) return;
+      isDragging.current = false;
+      const xy = getClientXy(event);
+      if (!xy) return;
+      const { clientX, clientY } = xy;
+      dragEndCallback({ x: clientX, y: clientY });
+    },
+    [isBlockingActiveInput]
+  );
+  return {
+    handleStart,
+    handleMove,
+    handleEnd
+  };
+};
+var folderEventSubject = new rxjs.Subject();
+var setFolderEvent = (newValue) => {
+  folderEventSubject.next(newValue);
+};
+var useFolderEvent = () => {
+  const [folderEvent, setFolderEvent2] = React2.useState(
+    null
+  );
+  React2.useEffect(() => {
+    const subscription = folderEventSubject.subscribe((e) => {
+      if (!e) return;
+      setFolderEvent2(e);
+    });
+    return () => {
+      if (subscription) {
+        subscription.unsubscribe();
+      }
+    };
+  }, []);
+  return { folderEvent };
+};
+function useFlexLayoutSplitScreen({
+  isSplitInitial = false,
+  parentDirection,
+  directionInitial = "row",
+  selfContainerName,
+  parentLayoutName,
+  layoutName
+}) {
+  const [direction, setDirection] = React2.useState(
+    directionInitial
+  );
+  const [isSplit, setIsSplit] = React2.useState(isSplitInitial);
+  const [boundaryContainerSize, setBoundaryContainerSize] = React2.useState(null);
+  const [centerDropTargetComponent, setCenterDropTargetComponent] = React2.useState([]);
+  const [afterDropTargetComponent, setAfterDropTargetComponent] = React2.useState([]);
+  const [beforeDropTargetComponent, setBeforeDropTargetComponent] = React2.useState([]);
+  const layoutRef = React2.useRef(null);
+  const dragState2 = useDragCapture(layoutRef);
+  React2.useEffect(() => {
+    if (!dragState2) {
+      setBoundaryContainerSize(null);
+      return;
+    }
+    const {
+      isDrop,
+      isDragging,
+      positionName,
+      containerName,
+      children: dropComponent,
+      isOver,
+      navigationTitle,
+      dropEndCallback,
+      x,
+      y,
+      screenKey
+    } = dragState2;
+    const orderName = positionName === "leftBoundary" || positionName === "topBoundary" ? "before" : positionName === "rightBoundary" || positionName === "bottomBoundary" ? "after" : "center";
+    if ((isOver || isDrop) && boundaryContainerSize) {
+      setBoundaryContainerSize(null);
+    }
+    if (selfContainerName.startsWith(containerName)) {
+      return;
+    }
+    if (isDrop && screenKey) {
+      const dropDirection = positionName === "leftBoundary" || positionName === "rightBoundary" ? "row" : "column";
+      if (!isSplit && !isOver) {
+        if (positionName !== "centerBoundary" && dropDirection !== parentDirection) {
+          setIsSplit(true);
+          setDirection(dropDirection);
+        }
+        dropMovementEventSubject.next({
+          state: "append",
+          targetContainerName: containerName,
+          targetParentLayoutName: parentLayoutName,
+          targetLayoutName: layoutName,
+          targetComponent: dropComponent,
+          orderName,
+          x,
+          y,
+          dropEndCallback,
+          dropTargetComponentEvent: {
+            navigationTitle,
+            dropDocumentOutsideOption: dragState2?.dropDocumentOutsideOption,
+            direction: dropDirection,
+            screenKey
+          }
+        });
+      }
+    }
+    if (isDragging && !isSplit && !isOver) {
+      const newSize = {
+        left: positionName === "rightBoundary" ? "50%" : "0",
+        top: positionName === "bottomBoundary" ? "50%" : "0",
+        width: positionName === "leftBoundary" || positionName === "rightBoundary" ? "50%" : "100%",
+        height: positionName === "topBoundary" || positionName === "bottomBoundary" ? "50%" : "100%"
+      };
+      if (JSON.stringify(boundaryContainerSize) !== JSON.stringify(newSize)) {
+        setBoundaryContainerSize(newSize);
+      }
+    }
+  }, [
+    dragState2,
+    isSplit,
+    boundaryContainerSize,
+    parentLayoutName,
+    layoutName,
+    selfContainerName,
+    direction
+  ]);
+  return {
+    direction,
+    setDirection,
+    isSplit,
+    setIsSplit,
+    boundaryContainerSize,
+    //setBoundaryContainerSize,
+    centerDropTargetComponent,
+    afterDropTargetComponent,
+    beforeDropTargetComponent,
+    setAfterDropTargetComponent,
+    setBeforeDropTargetComponent,
+    setCenterDropTargetComponent,
+    //dropTargetComponent,
+    //setDropTargetComponent,
+    //setDropPosition,
+    isOver: dragState2?.isOver,
+    layoutRef
+  };
+}
+var MAX_STEP = 18;
+function edgeVelocity(x, y) {
+  const w = window.innerWidth, h = window.innerHeight;
+  const mx = w * 0.15, my = h * 0.15;
+  let vx = 0;
+  if (x < mx)
+    vx = -((mx - x) / mx) * MAX_STEP;
+  else if (x > w - mx)
+    vx = (x - (w - mx)) / mx * MAX_STEP;
+  let vy = 0;
+  if (y < my)
+    vy = -((my - y) / my) * MAX_STEP;
+  else if (y > h - my)
+    vy = (y - (h - my)) / my * MAX_STEP;
+  return { vx, vy };
+}
+function FlexLayoutSplitScreenDragBox({
+  onMouseDown,
+  onTouchStart,
+  dropEndCallback,
+  style,
+  navigationTitle,
+  targetComponent,
+  containerName,
+  children,
+  className,
+  dropDocumentOutsideOption,
+  screenKey = Array.from(
+    window.crypto.getRandomValues(new Uint32Array(16)),
+    (e) => e.toString(32).padStart(2, "0")
+  ).join(""),
+  isBlockingActiveInput = false,
+  customData = {},
+  scrollTargetRef,
+  ...props
+}) {
+  const scrollRAF = React2.useRef(null);
+  const velocity = React2.useRef({ vx: 0, vy: 0 });
+  const ref = React2.useRef(null);
+  const clonedNodeRef = React2.useRef(null);
+  const clonedWidth = React2.useRef(null);
+  const clonedHeight = React2.useRef(null);
+  const hrefUrlRef = React2.useRef("");
+  const { handleStart, handleMove, handleEnd } = useDragEvents({
+    isBlockingActiveInput
+  });
+  const handleMoveWrapper = (event) => {
+    let x = 0;
+    let y = 0;
+    if (event.type === "touchmove") {
+      const t = event.touches[0];
+      x = t.clientX;
+      y = t.clientY;
+    } else {
+      const m = event;
+      x = m.clientX;
+      y = m.clientY;
+    }
+    const { vx, vy } = edgeVelocity(x, y);
+    const inEdge = vx !== 0 || vy !== 0;
+    if (clonedNodeRef.current?.isConnected && !inEdge) {
+      event.preventDefault();
+      if (scrollRAF.current) {
+        cancelAnimationFrame(scrollRAF.current);
+        scrollRAF.current = null;
+      }
+    }
+    if (clonedNodeRef.current?.isConnected && inEdge) {
+      event.preventDefault();
+      velocity.current = { vx, vy };
+      if (!scrollRAF.current) {
+        const step = () => {
+          const target = scrollTargetRef?.current ?? document.scrollingElement;
+          if (target?.scrollBy) {
+            target.scrollBy(
+              velocity.current.vx,
+              velocity.current.vy
+            );
+          } else {
+            window.scrollBy(
+              velocity.current.vx,
+              velocity.current.vy
+            );
+          }
+          if (velocity.current.vx === 0 && velocity.current.vy === 0) {
+            scrollRAF.current = null;
+            return;
+          }
+          scrollRAF.current = requestAnimationFrame(step);
+        };
+        scrollRAF.current = requestAnimationFrame(step);
+      }
+    }
+    if (event.type !== "touchmove") {
+      event.preventDefault();
+    }
+    handleMove({
+      event,
+      notDragCallback: ({ x: x2, y: y2 }) => {
+        if (clonedNodeRef.current) clonedNodeRef.current.remove();
+      },
+      dragStartCallback: ({ x: x2, y: y2 }) => {
+        if (!clonedNodeRef.current) return;
+        navigator.vibrate(100);
+        clonedNodeRef.current.style.left = `${x2 - (clonedWidth.current || 0) / 2}px`;
+        clonedNodeRef.current.style.top = `${y2 - (clonedHeight.current || 0) / 2}px`;
+      },
+      moveingCallback: ({ x: x2, y: y2 }) => {
+        if (clonedNodeRef.current?.isConnected) {
+          clonedNodeRef.current.style.left = `${x2 - (clonedWidth.current || 0) / 2}px`;
+          clonedNodeRef.current.style.top = `${y2 - (clonedHeight.current || 0) / 2}px`;
+        }
+        dragState.next({
+          isDragging: true,
+          isDrop: false,
+          navigationTitle,
+          children: targetComponent,
+          x: x2,
+          y: y2,
+          containerName,
+          dropDocumentOutsideOption,
+          customData
+        });
+      }
+    });
+  };
+  const handleEndWrapper = (event) => {
+    if (scrollRAF.current !== null) {
+      cancelAnimationFrame(scrollRAF.current);
+      scrollRAF.current = null;
+    }
+    velocity.current = { vx: 0, vy: 0 };
+    handleEnd({
+      event,
+      dragEndCallback: ({ x, y }) => {
+        const href = hrefUrlRef.current;
+        if (clonedNodeRef.current) clonedNodeRef.current.remove();
+        if (dropDocumentOutsideOption && isDocumentOut({ x, y })) {
+          if (dropDocumentOutsideOption.isNewTap || !dropDocumentOutsideOption.widthRatio && !dropDocumentOutsideOption.heightRatio) {
+            window.open(href, "_blank");
+          } else {
+            const width = window.innerWidth * (dropDocumentOutsideOption.widthRatio || 1);
+            const height = window.innerHeight * (dropDocumentOutsideOption.heightRatio || 1);
+            window.open(
+              href,
+              "_blank",
+              `width=${width},height=${height},left=${window.screenLeft - x * -1 - width},top=${window.screenTop + y}`
+            );
+          }
+        }
+        dragState.next({
+          isDragging: false,
+          isDrop: true,
+          navigationTitle,
+          children: targetComponent,
+          x,
+          y,
+          containerName,
+          dropDocumentOutsideOption,
+          dropEndCallback,
+          screenKey,
+          customData
+        });
+      }
+    });
+  };
+  React2.useEffect(() => {
+    if (ref.current) {
+      const clone = ref.current.cloneNode(true);
+      const originRect = ref.current.getBoundingClientRect();
+      clone.style.width = originRect.width + "px";
+      clone.style.height = originRect.height + "px";
+      clone.style.opacity = "0.3";
+      clone.style.backdropFilter = "blur(6px)";
+      clonedWidth.current = originRect.width;
+      clonedHeight.current = originRect.height;
+      if (dropDocumentOutsideOption?.openUrl) {
+        hrefUrlRef.current = dropDocumentOutsideOption.openUrl;
+        const href = document.createElement("span");
+        href.textContent = hrefUrlRef.current;
+        clone.prepend(href);
+      }
+      if (navigationTitle) {
+        const title = document.createElement("span");
+        title.textContent = navigationTitle;
+        clone.prepend(title);
+      }
+      clone.style.position = "fixed";
+      clonedNodeRef.current = clone;
+      clonedNodeRef.current.classList.add(
+        FlexLayout_default["flex-split-screen-drag-box-clone"]
+      );
+    }
+  }, []);
+  React2.useEffect(() => {
+    const moveEvents = [
+      "mousemove",
+      "touchmove"
+    ];
+    const endEvents = ["mouseup", "touchend"];
+    moveEvents.forEach((eventName) => {
+      window.addEventListener(eventName, handleMoveWrapper, {
+        passive: false
+      });
+    });
+    endEvents.forEach((eventName) => {
+      window.addEventListener(eventName, handleEndWrapper);
+    });
+    return () => {
+      moveEvents.forEach((eventName) => {
+        window.removeEventListener(eventName, handleMoveWrapper);
+      });
+      endEvents.forEach((eventName) => {
+        window.removeEventListener(eventName, handleEndWrapper);
+      });
+    };
+  }, [
+    customData,
+    targetComponent,
+    dropDocumentOutsideOption,
+    screenKey,
+    isBlockingActiveInput,
+    containerName,
+    navigationTitle,
+    dropEndCallback
+  ]);
+  React2.useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const onCtx = (e) => e.preventDefault();
+    el.addEventListener("contextmenu", onCtx);
+    return () => {
+      el.removeEventListener("contextmenu", onCtx);
+    };
+  }, []);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: `${className || ""} ${FlexLayout_default["flex-split-screen-drag-box"]}`,
+      ref,
+      onContextMenu: (e) => e.preventDefault(),
+      onMouseDown: (ev) => {
+        if (onMouseDown) {
+          Promise.resolve().then(() => onMouseDown(ev));
+        }
+        handleStart({
+          event: ev,
+          dragStartCallback: ({ x, y }) => {
+            if (clonedNodeRef.current) {
+              document.body.appendChild(
+                clonedNodeRef.current
+              );
+              if (ref.current) {
+                const originRect = ref.current.getBoundingClientRect();
+                clonedNodeRef.current.style.width = originRect.width + "px";
+                clonedNodeRef.current.style.height = originRect.height + "px";
+                clonedWidth.current = originRect.width;
+                clonedHeight.current = originRect.height;
+              }
+            }
+            if (clonedNodeRef.current?.isConnected) {
+              navigator.vibrate(100);
+              clonedNodeRef.current.style.left = `${x - (clonedWidth.current || 0) / 2}px`;
+              clonedNodeRef.current.style.top = `${y - (clonedHeight.current || 0) / 2}px`;
+            }
+            dragState.next({
+              isDragging: true,
+              isDrop: false,
+              navigationTitle,
+              children: targetComponent,
+              x,
+              y,
+              containerName,
+              dropDocumentOutsideOption,
+              customData
+            });
+          }
+        });
+      },
+      onTouchStart: (ev) => {
+        if (onTouchStart) {
+          Promise.resolve().then(() => onTouchStart(ev));
+        }
+        handleStart({
+          event: ev,
+          dragStartCallback: ({ x, y }) => {
+            if (clonedNodeRef.current) {
+              document.body.appendChild(
+                clonedNodeRef.current
+              );
+              if (ref.current) {
+                const originRect = ref.current.getBoundingClientRect();
+                clonedNodeRef.current.style.width = originRect.width + "px";
+                clonedNodeRef.current.style.height = originRect.height + "px";
+                clonedWidth.current = originRect.width;
+                clonedHeight.current = originRect.height;
+              }
+            }
+            if (clonedNodeRef.current?.isConnected) {
+              navigator.vibrate(100);
+              clonedNodeRef.current.style.left = `${x - (clonedWidth.current || 0) / 2}px`;
+              clonedNodeRef.current.style.top = `${y - (clonedHeight.current || 0) / 2}px`;
+            }
+            dragState.next({
+              isDragging: true,
+              isDrop: false,
+              navigationTitle,
+              children: targetComponent,
+              x,
+              y,
+              containerName,
+              dropDocumentOutsideOption,
+              customData
+            });
+          }
+        });
+      },
+      style: { ...style },
+      ...props
+    },
+    children
+  ));
+}
+
+// src/flex-layout/styles/listScroll.module.css
+var listScroll_default = {};
+
+// src/flex-layout/components/FlexLayoutSplitScreenScrollBox.tsx
+var FlexLayoutSplitScreenScrollBox = ({
+  className,
+  children,
+  keyName,
+  direction,
+  isDefaultScrollStyle = false,
+  ...props
+}) => {
+  const scrollRef = React2.useRef(null);
+  const [isMouseDown, setIsMouseDown] = React2.useState(false);
+  const scrollEventSubject = React2.useRef(new rxjs.Subject());
+  React2.useEffect(() => {
+    const mouseUpSubscribe = rxjs.fromEvent(
+      window,
+      "mouseup"
+    ).subscribe(() => {
+      setIsMouseDown(false);
+    });
+    const scrollEventSubscribe = scrollEventSubject.current.pipe(operators.throttleTime(70)).subscribe((position) => {
+      setScrollPosition(keyName, position);
+    });
+    const scrollSubscribe = getScrollPosition(keyName).pipe(operators.take(1)).subscribe((position) => {
+      if (scrollRef.current && position) {
+        scrollRef.current.scrollLeft = position.x;
+        scrollRef.current.scrollTop = position.y;
+      }
+    });
+    return () => {
+      removeScrollPosition(keyName);
+      mouseUpSubscribe.unsubscribe();
+      scrollSubscribe.unsubscribe();
+      scrollEventSubscribe.unsubscribe();
+    };
+  }, [keyName]);
+  React2.useEffect(() => {
+    if (!scrollRef.current) return;
+    let animationFrameId = null;
+    const handleWheel = (event) => {
+      if (!scrollRef.current || direction !== "x") return;
+      if (scrollRef.current.matches(":hover")) {
+        event.preventDefault();
+        const { deltaY } = event;
+        const newScrollLeft = scrollRef.current.scrollLeft + deltaY;
+        if (animationFrameId) {
+          cancelAnimationFrame(animationFrameId);
+        }
+        animationFrameId = requestAnimationFrame(() => {
+          scrollRef.current.scrollLeft = newScrollLeft;
+          scrollEventSubject.current.next({
+            x: newScrollLeft,
+            y: scrollRef.current.scrollTop
+          });
+          animationFrameId = null;
+        });
+      }
+    };
+    scrollRef.current.addEventListener("wheel", handleWheel, {
+      passive: false
+    });
+    return () => {
+      scrollRef.current?.removeEventListener("wheel", handleWheel);
+    };
+  }, []);
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      ref: scrollRef,
+      onMouseUp: () => setIsMouseDown(false),
+      onMouseDown: () => setIsMouseDown(true),
+      onMouseMove: (event) => {
+        if (!scrollRef.current || !isMouseDown || direction !== "x")
+          return;
+        scrollRef.current.scrollLeft += event.movementX * -1;
+        scrollEventSubject.current.next({
+          x: scrollRef.current.scrollLeft,
+          y: scrollRef.current.scrollTop
+        });
+      },
+      onScroll: () => {
+        if (!scrollRef.current) return;
+        scrollEventSubject.current.next({
+          x: scrollRef.current.scrollLeft,
+          y: scrollRef.current.scrollTop
+        });
+      },
+      className: `${className || ""} ${isDefaultScrollStyle ? listScroll_default["default-scroll"] : listScroll_default["list-scroll"]} ${direction ? listScroll_default[direction] : ""}`,
+      ...props
+    },
+    children
+  );
+};
+var FlexLayoutSplitScreenScrollBox_default = React2.memo(FlexLayoutSplitScreenScrollBox);
+
+// src/flex-layout/components/FlexLayoutSplitScreenDragBoxContainer.tsx
+function FlexLayoutSplitScreenDragBoxContainer({
+  className,
+  children,
+  layoutName,
+  ...props
+}) {
+  return /* @__PURE__ */ React.createElement(
+    FlexLayoutSplitScreenScrollBox_default,
+    {
+      keyName: layoutName,
+      className: `${FlexLayout_default["flex-split-screen-drag-box-title-container"]} ${className && className !== "" && className || ""}`,
+      direction: "x",
+      ...props
+    },
+    children
+  );
+}
+function FlexLayoutSplitScreenDragBoxItem({
+  children,
+  onClose,
+  isActive,
+  ...props
+}) {
+  React2.useEffect(() => {
+    allSplitScreenCount.next(allSplitScreenCount.value + 1);
+    return () => {
+      if (allSplitScreenCount.value <= 1) return;
+      allSplitScreenCount.next(allSplitScreenCount.value - 1);
+    };
+  }, []);
+  return /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: `${FlexLayout_default["flex-split-screen-drag-box-title-item"]} ${isActive ? FlexLayout_default["active"] : ""}`,
+      ...props
+    },
+    children,
+    /* @__PURE__ */ React.createElement("button", { type: "button", onClick: (ev) => onClose(ev) }, "X")
+  );
+}
+
+// src/flex-layout/components/FlexLayoutSplitScreenDragBoxTitleMore.tsx
+function FlexLayoutSplitScreenDragBoxTitleMore({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      ...props,
+      className: `${FlexLayout_default["flex-split-screen-drag-box-title-more"]} ${className || ""}`
+    },
+    /* @__PURE__ */ React.createElement("span", null, "."),
+    /* @__PURE__ */ React.createElement("span", null, "."),
+    /* @__PURE__ */ React.createElement("span", null, ".")
+  );
+}
+
+// src/flex-layout/components/FlexLayoutSplitScreen.tsx
+function isOverDrop({
+  x,
+  y,
+  element
+}) {
+  const {
+    x: elementX,
+    y: elementY,
+    right: elementRight,
+    bottom: elementBottom
+  } = element.getBoundingClientRect();
+  const isElementOver = x < elementX || x > elementRight || y < elementY || y > elementBottom;
+  return isElementOver;
+}
+function isInnerDrop({
+  x,
+  y,
+  element
+}) {
+  const {
+    x: elementX,
+    y: elementY,
+    right: elementRight,
+    bottom: elementBottom
+  } = element.getBoundingClientRect();
+  const isElementInner = x >= elementX && x <= elementRight && y >= elementY && y <= elementBottom;
+  return isElementInner;
+}
+var handleUpdateDropTargetComponents = ({
+  orderName,
+  parentOrderName,
+  containerName,
+  parentLayoutName,
+  layoutName,
+  dropComponent,
+  navigationTitle,
+  nextContainerName,
+  isUsePrefix = true,
+  beforeDropTargetComponent,
+  afterDropTargetComponent,
+  centerDropTargetComponent,
+  dropDocumentOutsideOption,
+  screenKey = Array.from(
+    window.crypto.getRandomValues(new Uint32Array(16)),
+    (e) => e.toString(32).padStart(2, "0")
+  ).join("")
+}) => {
+  const nextContainerNameOrderName = parentOrderName ? parentOrderName : orderName;
+  let listMap;
+  let list;
+  let key;
+  if (nextContainerNameOrderName === orderName || nextContainerNameOrderName === "center") {
+    listMap = orderName === "before" ? { beforeDropTargetComponent } : orderName === "after" ? { afterDropTargetComponent } : {
+      centerDropTargetComponent: centerDropTargetComponent.filter(
+        (e) => !e.containerName.split("_").at(0).startsWith(
+          containerName.split("_").at(0)
+        )
+      )
+    };
+  } else {
+    listMap = nextContainerNameOrderName === "before" ? { beforeDropTargetComponent } : { afterDropTargetComponent };
+  }
+  const entries = Object.entries(listMap)[0];
+  key = entries[0];
+  list = entries[1];
+  const newComponent = {
+    containerName: `${containerName + "_" + layoutName}${isUsePrefix ? "_" + orderName + "-" + list.length : ""}`,
+    component: React2.cloneElement(
+      dropComponent,
+      { key: screenKey, screenKey }
+    ),
+    navigationTitle,
+    dropDocumentOutsideOption,
+    screenKey: screenKey || Array.from(
+      window.crypto.getRandomValues(new Uint32Array(16)),
+      (e) => e.toString(32).padStart(2, "0")
+    ).join("")
+  };
+  let allComponents;
+  if (nextContainerName) {
+    const index = list.findIndex(
+      (item) => item.containerName === nextContainerName
+    );
+    if (index !== -1) {
+      if (nextContainerNameOrderName === orderName) {
+        if (orderName === "before") {
+          allComponents = [
+            ...list.slice(0, index),
+            newComponent,
+            ...list.slice(index)
+          ];
+        } else {
+          allComponents = [
+            ...list.slice(0, index + 1),
+            newComponent,
+            ...list.slice(index + 1)
+          ];
+        }
+      } else {
+        if (nextContainerNameOrderName === "after" && orderName === "before") {
+          allComponents = [
+            ...list.slice(0, index),
+            newComponent,
+            ...list.slice(index)
+          ];
+        } else if (nextContainerNameOrderName === "before" && orderName === "after") {
+          allComponents = [
+            ...list.slice(0, index + 1),
+            newComponent,
+            ...list.slice(index + 1)
+          ];
+        } else {
+          if (orderName === "before") {
+            allComponents = [
+              ...list.slice(0, index),
+              newComponent,
+              ...list.slice(index)
+            ];
+          } else {
+            allComponents = [
+              ...list.slice(0, index + 1),
+              newComponent,
+              ...list.slice(index + 1)
+            ];
+          }
+        }
+      }
+    } else {
+      if (nextContainerNameOrderName === "center" && orderName === "after") {
+        allComponents = [newComponent, ...list];
+      } else if (nextContainerNameOrderName === "center" && orderName === "before") {
+        allComponents = [...list, newComponent];
+      } else {
+        allComponents = orderName === "before" ? [newComponent, ...list] : [...list, newComponent];
+      }
+    }
+  } else {
+    allComponents = orderName === "before" ? [newComponent, ...list] : [...list, newComponent];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = allComponents.filter((item) => {
+    if (seen.has(item.containerName)) {
+      return false;
+    }
+    seen.add(item.containerName);
+    return true;
+  });
+  dropMovementEventSubject.next({
+    state: "append",
+    targetParentLayoutName: parentLayoutName,
+    targetLayoutName: layoutName,
+    targetContainerName: containerName,
+    orderName
+  });
+  return { [key]: result };
+};
+var handleRemove = (list, targetContainerName, orderNameSetter) => {
+  const result = list.filter((e) => e.containerName !== targetContainerName);
+  if (result.length != list.length)
+    orderNameSetter(list.length - result.length);
+  return result;
+};
+function getAdjacentItem(items, currentIndex) {
+  if (currentIndex + 1 < items.length) {
+    return {
+      adjacentItem: items[currentIndex + 1],
+      adjacentIndex: currentIndex + 1
+    };
+  } else if (currentIndex - 1 >= 0) {
+    return {
+      adjacentItem: items[currentIndex - 1],
+      adjacentIndex: currentIndex - 1
+    };
+  }
+  return { adjacentItem: null, adjacentIndex: currentIndex };
+}
+var getSelfOrderName = (containerName) => {
+  const result = containerName.split("_").at(-1)?.split("-").at(0)?.split("=").at(0);
+  if (["before", "center", "after"].some((e) => e === result)) {
+    return result;
+  } else {
+    return;
+  }
+};
+function FlexLayoutSplitScreen({
+  children,
+  containerName,
+  layoutName,
+  navigationTitle,
+  dropDocumentOutsideOption,
+  screenKey
+}) {
+  const {
+    direction,
+    isSplit,
+    boundaryContainerSize,
+    afterDropTargetComponent,
+    beforeDropTargetComponent,
+    centerDropTargetComponent,
+    setAfterDropTargetComponent,
+    setBeforeDropTargetComponent,
+    setCenterDropTargetComponent,
+    layoutRef,
+    setIsSplit,
+    setDirection
+  } = useFlexLayoutSplitScreen({
+    isSplitInitial: false,
+    directionInitial: "row",
+    selfContainerName: containerName,
+    parentLayoutName: "",
+    layoutName
+  });
+  React2.useEffect(() => {
+    resetRootSplitScreen(layoutName);
+    const subscribe = getSplitScreen(layoutName, layoutName).subscribe((layoutInfo) => {
+      if (layoutInfo) {
+        setBeforeDropTargetComponent([
+          ...layoutInfo.beforeDropTargetComponent
+        ]);
+        setAfterDropTargetComponent([
+          ...layoutInfo.afterDropTargetComponent
+        ]);
+        setCenterDropTargetComponent([
+          ...layoutInfo.centerDropTargetComponent
+        ]);
+        setDirection(layoutInfo.direction);
+        if (layoutInfo.beforeDropTargetComponent.length !== 0 || layoutInfo.afterDropTargetComponent.length !== 0) {
+          setIsSplit(true);
+        }
+      } else {
+        setSplitScreen(layoutName, layoutName, {
+          afterDropTargetComponent: [],
+          beforeDropTargetComponent: [],
+          centerDropTargetComponent: [
+            {
+              containerName,
+              component: children,
+              navigationTitle,
+              dropDocumentOutsideOption,
+              screenKey: screenKey ? screenKey : Array.from(
+                window.crypto.getRandomValues(
+                  new Uint32Array(16)
+                ),
+                (e) => e.toString(32).padStart(2, "0")
+              ).join("")
+            }
+          ],
+          direction
+        });
+      }
+    });
+    return () => {
+      subscribe.unsubscribe();
+      resetRootSplitScreen(layoutName);
+    };
+  }, [layoutName]);
+  React2.useEffect(() => {
+    const subscribe = dropMovementEventSubject.pipe(
+      rxjs.distinctUntilChanged((prev, curr) => {
+        const filterChildren2 = (obj) => {
+          const {
+            children: children2,
+            component,
+            targetComponent,
+            x,
+            y,
+            ...rest
+          } = obj || {};
+          return rest;
+        };
+        return equal__default.default(filterChildren2(prev), filterChildren2(curr));
+      })
+    ).subscribe((event) => {
+      if (event.state === "remove") {
+        if (event.targetParentLayoutName === layoutName || event.targetParentLayoutName === "" && event.targetLayoutName === layoutName) {
+          requestAnimationFrame(() => {
+            let removeCallback = (removeOrderName) => {
+              if (event.nextContainerName && event.dropTargetComponentEvent && event.targetComponent) {
+                const targetComponentsMap = handleUpdateDropTargetComponents({
+                  orderName: removeOrderName,
+                  containerName: event.nextContainerName,
+                  parentLayoutName: "",
+                  layoutName,
+                  dropComponent: event.targetComponent,
+                  navigationTitle: event.dropTargetComponentEvent.navigationTitle,
+                  isUsePrefix: true,
+                  afterDropTargetComponent,
+                  beforeDropTargetComponent,
+                  centerDropTargetComponent,
+                  dropDocumentOutsideOption,
+                  screenKey: event.dropTargetComponentEvent.screenKey
+                });
+                setSplitScreen(layoutName, layoutName, {
+                  ...getCurrentSplitScreenComponents(
+                    layoutName,
+                    layoutName
+                  ) || {
+                    afterDropTargetComponent,
+                    beforeDropTargetComponent,
+                    centerDropTargetComponent,
+                    direction
+                  },
+                  ...targetComponentsMap
+                });
+                Promise.resolve().then(
+                  () => event.dropEndCallback && event.dropEndCallback({
+                    x: event.x,
+                    y: event.y,
+                    containerName
+                  })
+                );
+              }
+            };
+            const currentComponents = getCurrentSplitScreenComponents(
+              layoutName,
+              layoutName
+            );
+            const afterList = handleRemove(
+              currentComponents?.afterDropTargetComponent || afterDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("after")
+            );
+            const beforList = handleRemove(
+              currentComponents?.beforeDropTargetComponent || beforeDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("before")
+            );
+            const centerList = handleRemove(
+              currentComponents?.centerDropTargetComponent || centerDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("center")
+            );
+            setSplitScreen(layoutName, layoutName, {
+              afterDropTargetComponent: afterList,
+              beforeDropTargetComponent: beforList,
+              centerDropTargetComponent: centerList,
+              direction
+            });
+          });
+        }
+      } else if (event.state === "append") {
+        const {
+          x,
+          y,
+          dropEndCallback,
+          dropTargetComponentEvent,
+          orderName,
+          parentOrderName,
+          targetLayoutName,
+          targetParentLayoutName,
+          targetContainerName,
+          targetComponent,
+          nextContainerName
+        } = event;
+        if (layoutRef.current && orderName && x && y && targetComponent && dropTargetComponentEvent && targetLayoutName === layoutName && isInnerDrop({ x, y, element: layoutRef.current })) {
+          const {
+            direction: dropDirection,
+            navigationTitle: navigationTitle2,
+            dropDocumentOutsideOption: dropDocumentOutsideOption2
+          } = dropTargetComponentEvent;
+          const isOrderNameNotCenter = orderName !== "center";
+          const isOrderNameCenterAndFirstScreen = orderName === "center" && centerDropTargetComponent.length <= 1;
+          if (isOrderNameNotCenter || isOrderNameCenterAndFirstScreen) {
+            setIsSplit(true);
+            if (isOrderNameNotCenter) {
+              setDirection(dropDirection);
+              const targetComponentsMap = handleUpdateDropTargetComponents({
+                orderName,
+                parentOrderName,
+                containerName: targetContainerName,
+                nextContainerName,
+                dropComponent: targetComponent,
+                parentLayoutName: "",
+                layoutName,
+                navigationTitle: navigationTitle2,
+                isUsePrefix: true,
+                afterDropTargetComponent,
+                beforeDropTargetComponent,
+                centerDropTargetComponent,
+                dropDocumentOutsideOption: dropDocumentOutsideOption2
+              });
+              setSplitScreen(layoutName, layoutName, {
+                ...{
+                  afterDropTargetComponent,
+                  beforeDropTargetComponent,
+                  centerDropTargetComponent,
+                  direction: dropDirection
+                },
+                ...targetComponentsMap,
+                ...{ direction: dropDirection }
+              });
+              Promise.resolve().then(
+                () => dropEndCallback && dropEndCallback({
+                  x: event.x,
+                  y: event.y,
+                  containerName
+                })
+              );
+            } else {
+              const childScreenInfo = getCurrentSplitScreenComponents(
+                layoutName,
+                `${layoutName}_center=${centerDropTargetComponent[0].screenKey}`
+              ) || {
+                afterDropTargetComponent: [],
+                beforeDropTargetComponent: [],
+                centerDropTargetComponent: [],
+                direction
+              };
+              setSplitScreen(
+                layoutName,
+                `${layoutName}_center=${centerDropTargetComponent[0].screenKey}`,
+                {
+                  ...childScreenInfo,
+                  ...{
+                    centerDropTargetComponent: [
+                      centerDropTargetComponent[0],
+                      {
+                        containerName: `${targetContainerName}_${layoutName}_${orderName}`,
+                        component: targetComponent,
+                        dropDocumentOutsideOption: dropDocumentOutsideOption2,
+                        screenKey: centerDropTargetComponent[0].screenKey,
+                        navigationTitle: navigationTitle2
+                      }
+                    ]
+                  }
+                }
+              );
+            }
+          }
+        }
+      }
+    });
+    return () => {
+      subscribe.unsubscribe();
+    };
+  }, [
+    direction,
+    layoutName,
+    isSplit,
+    beforeDropTargetComponent,
+    afterDropTargetComponent,
+    centerDropTargetComponent
+  ]);
+  return /* @__PURE__ */ React.createElement("div", { className: `${FlexLayout_default["flex-split-screen"]}`, ref: layoutRef }, /* @__PURE__ */ React.createElement(
+    FlexLayout,
+    {
+      direction,
+      layoutName,
+      "data-is_split": isSplit,
+      panelMovementMode: "bulldozer"
+    },
+    beforeDropTargetComponent.length != 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, beforeDropTargetComponent.map(
+      ({
+        containerName: cName,
+        component,
+        navigationTitle: navigationTitle2,
+        dropDocumentOutsideOption: dropDocumentOutsideOption2,
+        screenKey: screenKey2
+      }, i) => /* @__PURE__ */ React.createElement(
+        FlexLayoutContainer,
+        {
+          containerName: cName,
+          isInitialResizable: true,
+          isResizePanel: true,
+          key: cName
+        },
+        /* @__PURE__ */ React.createElement(
+          FlexLayoutSplitScreenChild,
+          {
+            parentDirection: direction,
+            layoutName: `${layoutName}_before`,
+            parentLayoutName: layoutName,
+            containerName: cName,
+            depth: 1,
+            rootRef: layoutRef,
+            screenKey: screenKey2,
+            initialCenterComponents: [
+              {
+                navigationTitle: navigationTitle2,
+                component,
+                containerName: cName,
+                dropDocumentOutsideOption: dropDocumentOutsideOption2,
+                screenKey: screenKey2
+              }
+            ],
+            rootName: layoutName
+          }
+        )
+      )
+    )) : /* @__PURE__ */ React.createElement("div", null),
+    centerDropTargetComponent.length === 0 ? /* @__PURE__ */ React.createElement("div", null) : /* @__PURE__ */ React.createElement(
+      FlexLayoutContainer,
+      {
+        containerName: `${centerDropTargetComponent[0].containerName}`,
+        isInitialResizable: true,
+        isResizePanel: isSplit
+      },
+      isSplit ? /* @__PURE__ */ React.createElement(
+        FlexLayoutSplitScreenChild,
+        {
+          parentDirection: direction,
+          layoutName: `${layoutName}_center`,
+          parentLayoutName: layoutName,
+          containerName: `${centerDropTargetComponent[0].containerName}`,
+          depth: 0,
+          rootRef: layoutRef,
+          screenKey: centerDropTargetComponent[0].screenKey,
+          initialCenterComponents: [
+            {
+              navigationTitle: centerDropTargetComponent[0].navigationTitle,
+              component: centerDropTargetComponent[0].component,
+              containerName: centerDropTargetComponent[0].containerName,
+              dropDocumentOutsideOption: centerDropTargetComponent[0].dropDocumentOutsideOption,
+              screenKey: centerDropTargetComponent[0].screenKey
+            }
+          ],
+          rootName: layoutName
+        }
+      ) : /* @__PURE__ */ React.createElement(
+        FlexLayoutSplitScreenScrollBox_default,
+        {
+          keyName: centerDropTargetComponent[0].containerName,
+          isDefaultScrollStyle: true
+        },
+        centerDropTargetComponent[0].component
+      )
+    ),
+    afterDropTargetComponent.length != 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, afterDropTargetComponent.map(
+      ({
+        containerName: cName,
+        component,
+        navigationTitle: navigationTitle2,
+        dropDocumentOutsideOption: dropDocumentOutsideOption2,
+        screenKey: screenKey2
+      }, i) => /* @__PURE__ */ React.createElement(
+        FlexLayoutContainer,
+        {
+          containerName: cName,
+          isInitialResizable: true,
+          isResizePanel: afterDropTargetComponent.length - 1 !== i,
+          key: cName
+        },
+        /* @__PURE__ */ React.createElement(
+          FlexLayoutSplitScreenChild,
+          {
+            parentDirection: direction,
+            layoutName: `${layoutName}_after`,
+            parentLayoutName: layoutName,
+            containerName: cName,
+            depth: 1,
+            rootRef: layoutRef,
+            screenKey: screenKey2,
+            initialCenterComponents: [
+              {
+                navigationTitle: navigationTitle2,
+                component,
+                containerName: cName,
+                dropDocumentOutsideOption: dropDocumentOutsideOption2,
+                screenKey: screenKey2
+              }
+            ],
+            rootName: layoutName
+          }
+        )
+      )
+    )) : /* @__PURE__ */ React.createElement("div", null)
+  ), boundaryContainerSize && /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: `${FlexLayout_default["flex-split-screen-boundary-container"]}`,
+      style: { ...boundaryContainerSize }
+    },
+    "\u2B07\uFE0F\uB4DC\uB86D\uD558\uBA74 \uD654\uBA74\uC774 \uBD84\uD560\uB429\uB2C8\uB2E4."
+  ));
+}
+function FlexLayoutSplitScreenChild({
+  containerName,
+  layoutName,
+  parentLayoutName,
+  parentDirection,
+  depth,
+  //isSplit: isSplitInitial,
+  rootRef,
+  rootName,
+  initialCenterComponents,
+  screenKey
+}) {
+  const {
+    direction,
+    isSplit,
+    boundaryContainerSize,
+    afterDropTargetComponent,
+    beforeDropTargetComponent,
+    centerDropTargetComponent,
+    setAfterDropTargetComponent,
+    setBeforeDropTargetComponent,
+    setCenterDropTargetComponent,
+    layoutRef,
+    setIsSplit,
+    setDirection
+  } = useFlexLayoutSplitScreen({
+    isSplitInitial: false,
+    directionInitial: "row",
+    parentDirection,
+    selfContainerName: containerName,
+    parentLayoutName,
+    layoutName
+  });
+  const [isEmptyContent, setIsEmptyContent] = React2.useState(false);
+  const [activeIndex, setActiveIndex] = React2.useState(0);
+  const centerDropTargetComponentRef = React2.useRef(centerDropTargetComponent);
+  const activeIndexRef = React2.useRef(activeIndex);
+  React2.useEffect(() => {
+    const subscribe = getSplitScreen(rootName, `${layoutName}=${screenKey}`).pipe(rxjs.take(1)).subscribe((layoutInfo) => {
+      setSplitScreen(rootName, `${layoutName}=${screenKey}`, {
+        afterDropTargetComponent: layoutInfo?.afterDropTargetComponent || [],
+        beforeDropTargetComponent: layoutInfo?.beforeDropTargetComponent || [],
+        centerDropTargetComponent: layoutInfo?.centerDropTargetComponent || initialCenterComponents || [],
+        direction: layoutInfo?.direction || direction
+      });
+    });
+    return () => {
+      removeSplitScreenChild(rootName, layoutName);
+      subscribe.unsubscribe();
+    };
+  }, [rootName, layoutName, initialCenterComponents]);
+  React2.useEffect(() => {
+    const subscribe = getSplitScreen(rootName, `${layoutName}=${screenKey}`).subscribe((layoutInfo) => {
+      if (layoutInfo) {
+        setBeforeDropTargetComponent([
+          ...layoutInfo.beforeDropTargetComponent
+        ]);
+        setAfterDropTargetComponent([
+          ...layoutInfo.afterDropTargetComponent
+        ]);
+        setCenterDropTargetComponent([
+          ...layoutInfo.centerDropTargetComponent
+        ]);
+        setDirection(layoutInfo.direction);
+        if (layoutInfo.beforeDropTargetComponent.length !== 0 || layoutInfo.afterDropTargetComponent.length !== 0) {
+          setIsSplit(true);
+        } else if (layoutInfo.beforeDropTargetComponent.length === 0 && layoutInfo.centerDropTargetComponent.length === 0 && layoutInfo.afterDropTargetComponent.length === 0) {
+          dropMovementEventSubject.next({
+            state: "remove",
+            targetContainerName: containerName,
+            targetParentLayoutName: "",
+            targetLayoutName: parentLayoutName
+          });
+          setIsEmptyContent(true);
+        }
+      }
+    });
+    return () => {
+      subscribe.unsubscribe();
+    };
+  }, [rootName, layoutName]);
+  React2.useEffect(() => {
+    const subscribe = dropMovementEventSubject.pipe(
+      rxjs.distinctUntilChanged((prev, curr) => {
+        const filterChildren2 = (obj) => {
+          const {
+            children,
+            component,
+            targetComponent,
+            x,
+            y,
+            ...rest
+          } = obj || {};
+          return rest;
+        };
+        return equal__default.default(filterChildren2(prev), filterChildren2(curr));
+      })
+    ).subscribe((event) => {
+      if (event.state === "remove") {
+        if (event.targetParentLayoutName === layoutName || event.targetParentLayoutName === "" && event.targetLayoutName === layoutName) {
+          requestAnimationFrame(() => {
+            let removeCallback = (removeOrderName) => {
+              if (event.nextContainerName && event.dropTargetComponentEvent && event.targetComponent) {
+                const targetComponentsMap = handleUpdateDropTargetComponents({
+                  orderName: removeOrderName,
+                  containerName: event.nextContainerName,
+                  parentLayoutName,
+                  layoutName,
+                  dropComponent: event.targetComponent,
+                  navigationTitle: event.dropTargetComponentEvent.navigationTitle,
+                  isUsePrefix: true,
+                  afterDropTargetComponent,
+                  beforeDropTargetComponent,
+                  centerDropTargetComponent,
+                  dropDocumentOutsideOption: event.dropTargetComponentEvent?.dropDocumentOutsideOption,
+                  screenKey: event.dropTargetComponentEvent.screenKey
+                });
+                setSplitScreen(
+                  rootName,
+                  `${layoutName}=${screenKey}`,
+                  {
+                    ...getCurrentSplitScreenComponents(
+                      rootName,
+                      `${layoutName}=${screenKey}`
+                    ) || {
+                      afterDropTargetComponent,
+                      beforeDropTargetComponent,
+                      centerDropTargetComponent,
+                      direction
+                    },
+                    ...targetComponentsMap
+                  }
+                );
+                Promise.resolve().then(
+                  () => event.dropEndCallback && event.dropEndCallback({
+                    x: event.x,
+                    y: event.y,
+                    containerName
+                  })
+                );
+              }
+            };
+            const currentComponents = getCurrentSplitScreenComponents(
+              rootName,
+              `${layoutName}=${screenKey}`
+            );
+            const afterList = handleRemove(
+              currentComponents?.afterDropTargetComponent || afterDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("after")
+            );
+            const beforList = handleRemove(
+              currentComponents?.beforeDropTargetComponent || beforeDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("before")
+            );
+            const centerList = handleRemove(
+              currentComponents?.centerDropTargetComponent || centerDropTargetComponent,
+              event.targetContainerName,
+              () => removeCallback("center")
+            );
+            setSplitScreen(
+              rootName,
+              `${layoutName}=${screenKey}`,
+              {
+                afterDropTargetComponent: afterList,
+                beforeDropTargetComponent: beforList,
+                centerDropTargetComponent: centerList,
+                direction
+              }
+            );
+          });
+        }
+      } else if (event.state === "append") {
+        const {
+          x,
+          y,
+          dropEndCallback,
+          dropTargetComponentEvent,
+          orderName,
+          targetLayoutName,
+          targetParentLayoutName,
+          targetContainerName,
+          targetComponent,
+          nextContainerName,
+          parentOrderName
+        } = event;
+        if (layoutRef.current && orderName && x && y && dropTargetComponentEvent && isInnerDrop({ x, y, element: layoutRef.current })) {
+          const {
+            direction: dropDirection,
+            navigationTitle,
+            dropDocumentOutsideOption,
+            screenKey: containerScreenKey
+          } = dropTargetComponentEvent;
+          if (
+            //orderName !== 'center' &&
+            targetLayoutName === layoutName && targetComponent
+          ) {
+            if (dropDirection === parentDirection && orderName !== "center") {
+              dropMovementEventSubject.next({
+                state: "append",
+                targetContainerName,
+                targetParentLayoutName: "",
+                targetLayoutName: parentLayoutName,
+                targetComponent,
+                nextContainerName: containerName,
+                parentOrderName: getSelfOrderName(layoutName) || orderName,
+                orderName,
+                x,
+                y,
+                dropEndCallback,
+                dropTargetComponentEvent: {
+                  navigationTitle,
+                  dropDocumentOutsideOption,
+                  direction: parentDirection,
+                  screenKey
+                }
+              });
+            } else {
+              if (orderName !== "center") {
+                setDirection(dropDirection);
+                setIsSplit(true);
+              }
+              const targetComponentsMap = handleUpdateDropTargetComponents({
+                orderName,
+                parentOrderName,
+                containerName: targetContainerName,
+                nextContainerName,
+                parentLayoutName,
+                layoutName,
+                dropComponent: targetComponent,
+                navigationTitle,
+                isUsePrefix: orderName !== "center",
+                afterDropTargetComponent,
+                beforeDropTargetComponent,
+                centerDropTargetComponent,
+                dropDocumentOutsideOption
+              });
+              setSplitScreen(
+                rootName,
+                `${layoutName}=${screenKey}`,
+                {
+                  ...getCurrentSplitScreenComponents(
+                    rootName,
+                    `${layoutName}=${screenKey}`
+                  ) || {
+                    afterDropTargetComponent,
+                    beforeDropTargetComponent,
+                    centerDropTargetComponent,
+                    direction
+                  },
+                  ...targetComponentsMap,
+                  ...{ direction: dropDirection }
+                }
+              );
+              Promise.resolve().then(
+                () => event.dropEndCallback && event.dropEndCallback({
+                  x: event.x,
+                  y: event.y,
+                  containerName
+                })
+              );
+            }
+          }
+        }
+      }
+    });
+    return () => {
+      subscribe.unsubscribe();
+    };
+  }, [
+    direction,
+    parentDirection,
+    parentLayoutName,
+    layoutName,
+    beforeDropTargetComponent,
+    afterDropTargetComponent,
+    centerDropTargetComponent
+  ]);
+  React2.useEffect(() => {
+    centerDropTargetComponentRef.current = centerDropTargetComponent;
+  }, [centerDropTargetComponent]);
+  React2.useEffect(() => {
+    activeIndexRef.current = activeIndex;
+  }, [activeIndex]);
+  const [isOnlyOneScreen, setIsOnlyOneScreen] = React2.useState(false);
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, !isEmptyContent && /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      className: `${FlexLayout_default["flex-split-screen"]}`,
+      ref: layoutRef
+    },
+    /* @__PURE__ */ React.createElement(
+      FlexLayout,
+      {
+        direction,
+        layoutName: `${layoutName}`,
+        panelMovementMode: "bulldozer"
+      },
+      beforeDropTargetComponent.length != 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, beforeDropTargetComponent.map(
+        ({
+          containerName: cName,
+          component,
+          navigationTitle,
+          dropDocumentOutsideOption,
+          screenKey: screenKey2
+        }, i) => /* @__PURE__ */ React.createElement(
+          FlexLayoutContainer,
+          {
+            containerName: cName,
+            isInitialResizable: true,
+            isResizePanel: true,
+            key: cName
+          },
+          /* @__PURE__ */ React.createElement(
+            FlexLayoutSplitScreenChild,
+            {
+              parentDirection: direction,
+              layoutName: `${layoutName}_before-${depth}`,
+              parentLayoutName: layoutName,
+              containerName: cName,
+              depth: depth + 1,
+              rootRef,
+              screenKey: screenKey2,
+              initialCenterComponents: [
+                {
+                  navigationTitle,
+                  component,
+                  containerName: cName,
+                  dropDocumentOutsideOption,
+                  screenKey: screenKey2
+                }
+              ],
+              rootName
+            }
+          )
+        )
+      )) : /* @__PURE__ */ React.createElement("div", null),
+      centerDropTargetComponent.length != 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+        FlexLayoutContainer,
+        {
+          containerName: `${(centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0]).containerName}`,
+          isInitialResizable: true,
+          isResizePanel: isSplit,
+          key: (centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0]).containerName
+        },
+        isSplit ? /* @__PURE__ */ React.createElement("div", { "data-key": screenKey }, /* @__PURE__ */ React.createElement(
+          FlexLayoutSplitScreenChild,
+          {
+            parentDirection: direction,
+            layoutName: `${layoutName}_center-${depth}`,
+            parentLayoutName: layoutName,
+            containerName: `${(centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0]).containerName}`,
+            depth: depth + 1,
+            rootRef,
+            initialCenterComponents: centerDropTargetComponent.map(
+              ({
+                navigationTitle,
+                component,
+                containerName: cName,
+                dropDocumentOutsideOption,
+                screenKey: centerScreenKey
+              }) => ({
+                navigationTitle,
+                component,
+                containerName: cName,
+                dropDocumentOutsideOption,
+                screenKey: centerScreenKey
+              })
+            ),
+            screenKey,
+            rootName
+          }
+        )) : /* @__PURE__ */ React.createElement(
+          FlexLayoutSplitScreenScrollBox_default,
+          {
+            keyName: (centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0]).containerName,
+            isDefaultScrollStyle: true
+          },
+          !isOnlyOneScreen && /* @__PURE__ */ React.createElement(
+            "div",
+            {
+              className: `${FlexLayout_default["flex-split-screen-drag-box-title-wrapper-sticky"]}`
+            },
+            /* @__PURE__ */ React.createElement(
+              "div",
+              {
+                "data-is_split": isSplit,
+                "data-layout_name": layoutName,
+                "data-parent_layout_name": parentLayoutName,
+                "data-container_name": `${(centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0]).containerName}`,
+                className: `${FlexLayout_default["flex-split-screen-drag-box-title-wrapper"]}`
+              },
+              /* @__PURE__ */ React.createElement(
+                FlexLayoutSplitScreenDragBoxContainer,
+                {
+                  key: layoutName,
+                  "data-layout_name": layoutName,
+                  layoutName
+                },
+                centerDropTargetComponent.map(
+                  (item, index) => /* @__PURE__ */ React.createElement(
+                    FlexLayoutSplitScreenDragBoxItem,
+                    {
+                      onClose: (ev) => {
+                        if (activeIndexRef.current === index && centerDropTargetComponent.length === 1) {
+                          dropMovementEventSubject.next(
+                            {
+                              state: "remove",
+                              targetContainerName: containerName,
+                              targetParentLayoutName: parentLayoutName,
+                              targetLayoutName: layoutName
+                            }
+                          );
+                        } else {
+                          if (centerDropTargetComponent.length === activeIndexRef.current + 1) {
+                            setActiveIndex(
+                              activeIndexRef.current - 1
+                            );
+                          }
+                          setCenterDropTargetComponent(
+                            (prev) => {
+                              const result = handleRemove(
+                                prev,
+                                item.containerName,
+                                () => {
+                                }
+                              );
+                              return result;
+                            }
+                          );
+                        }
+                      },
+                      key: item.navigationTitle + layoutName + item.containerName,
+                      isActive: activeIndex === index
+                    },
+                    /* @__PURE__ */ React.createElement(
+                      FlexLayoutSplitScreenDragBox,
+                      {
+                        onClick: () => {
+                          setActiveIndex(
+                            index
+                          );
+                        },
+                        containerName: item.containerName,
+                        dropDocumentOutsideOption: item.dropDocumentOutsideOption,
+                        targetComponent: item.component,
+                        navigationTitle: item.navigationTitle,
+                        "data-container-name": item.containerName,
+                        "data-layout-name": layoutName,
+                        "data-parent-layout-name": parentLayoutName,
+                        dropEndCallback: ({
+                          x,
+                          y,
+                          containerName: appendContainerName
+                        }) => {
+                          if (!rootRef.current || !layoutRef.current)
+                            return;
+                          const isRootOver = isOverDrop(
+                            {
+                              x,
+                              y,
+                              element: rootRef.current
+                            }
+                          );
+                          const isLayoutInner = isInnerDrop(
+                            {
+                              x,
+                              y,
+                              element: layoutRef.current
+                            }
+                          );
+                          if (!isRootOver && !isLayoutInner || !isRootOver && isLayoutInner && centerDropTargetComponentRef.current.length > 1) {
+                            const option = {};
+                            if (centerDropTargetComponentRef.current.length > 1) {
+                              const {
+                                adjacentItem,
+                                adjacentIndex
+                              } = getAdjacentItem(
+                                centerDropTargetComponentRef.current,
+                                activeIndexRef.current
+                              );
+                              if (adjacentItem && activeIndexRef.current === index) {
+                                Object.assign(
+                                  option,
+                                  {
+                                    x,
+                                    y,
+                                    targetComponent: adjacentItem.component,
+                                    nextContainerName: adjacentItem.containerName,
+                                    orderName: "center",
+                                    dropTargetComponentEvent: {
+                                      navigationTitle: adjacentItem.navigationTitle,
+                                      dropDocumentOutsideOption: adjacentItem.dropDocumentOutsideOption,
+                                      direction,
+                                      screenKey
+                                    }
+                                  }
+                                );
+                              }
+                            }
+                            if (index === 0) {
+                              dropMovementEventSubject.next(
+                                {
+                                  state: "remove",
+                                  targetContainerName: item.containerName,
+                                  targetParentLayoutName: parentLayoutName,
+                                  targetLayoutName: layoutName,
+                                  ...option
+                                }
+                              );
+                            } else {
+                              dropMovementEventSubject.next(
+                                {
+                                  state: "remove",
+                                  targetContainerName: item.containerName,
+                                  targetParentLayoutName: "",
+                                  targetLayoutName: layoutName,
+                                  ...option
+                                }
+                              );
+                            }
+                          }
+                        }
+                      },
+                      item.navigationTitle
+                    )
+                  )
+                )
+              ),
+              /* @__PURE__ */ React.createElement(FlexLayoutSplitScreenDragBoxTitleMore, null)
+            )
+          ),
+          (() => {
+            const target = centerDropTargetComponent[activeIndex] || centerDropTargetComponent[0];
+            return target.component;
+          })()
+        )
+      )) : /* @__PURE__ */ React.createElement("div", null),
+      afterDropTargetComponent.length != 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, afterDropTargetComponent.map(
+        ({
+          containerName: cName,
+          component,
+          navigationTitle,
+          dropDocumentOutsideOption,
+          screenKey: screenKey2
+        }, i) => /* @__PURE__ */ React.createElement(
+          FlexLayoutContainer,
+          {
+            containerName: cName,
+            isInitialResizable: true,
+            isResizePanel: i !== afterDropTargetComponent.length - 1,
+            key: cName
+          },
+          /* @__PURE__ */ React.createElement(
+            FlexLayoutSplitScreenChild,
+            {
+              parentDirection: direction,
+              layoutName: `${layoutName}_after-${depth}`,
+              parentLayoutName: layoutName,
+              containerName: cName,
+              depth: depth + 1,
+              rootRef,
+              screenKey: screenKey2,
+              initialCenterComponents: [
+                {
+                  navigationTitle,
+                  component,
+                  containerName: cName,
+                  dropDocumentOutsideOption,
+                  screenKey: screenKey2
+                }
+              ],
+              rootName
+            }
+          )
+        )
+      )) : /* @__PURE__ */ React.createElement("div", null)
+    ),
+    boundaryContainerSize && /* @__PURE__ */ React.createElement(
+      "div",
+      {
+        className: `${FlexLayout_default["flex-split-screen-boundary-container"]}`,
+        style: { ...boundaryContainerSize }
+      },
+      "\u2B07\uFE0F\uB4DC\uB86D\uD558\uBA74 \uD654\uBA74\uC774 \uBD84\uD560\uB429\uB2C8\uB2E4."
+    )
+  ));
+}
+function clamp(n, min, max) {
+  return Math.max(min, Math.min(max, n));
+}
+function pickDefaultScrollRoot() {
+  if (typeof document === "undefined") return null;
+  let el = document.body;
+  while (el && el !== document.documentElement && el !== document.body) {
+    const style = getComputedStyle(el);
+    const oy = style.overflowY;
+    const ox = style.overflowX;
+    const scrollable = oy === "auto" || oy === "scroll" || ox === "auto" || ox === "scroll";
+    if (scrollable) return el;
+    el = el.parentElement;
+  }
+  return null;
+}
+function isVerticalScroll(root) {
+  if (typeof window == "undefined") return true;
+  if (!root) {
+    return document.documentElement.scrollHeight > window.innerHeight + 1;
+  }
+  const el = root;
+  return el.scrollHeight > el.clientHeight + 1;
+}
+var dpr = typeof window != "undefined" ? window.devicePixelRatio || 1 : 1;
+function quantizeToDevicePixel(n) {
+  return Math.round(n * dpr) / dpr;
+}
+var FlexLayoutStickyBox = ({
+  edge = "auto",
+  offset = 16,
+  scrollRoot = null,
+  debug = false,
+  children,
+  style,
+  className,
+  onTranslateChange = () => {
+  },
+  ...rest
+}) => {
+  const offsetRef = React2.useRef(offset);
+  const rootRef = React2.useRef(null);
+  const contentRef = React2.useRef(null);
+  const mutatingRef = React2.useRef(false);
+  const lastOffsetRef = React2.useRef(0);
+  const [resolvedEdge, setResolvedEdge] = React2.useState("top");
+  const rafId = React2.useRef(null);
+  const [contentDynamicStyle, setContentDynamicStyle] = React2.useState({});
+  React2.useEffect(() => {
+    setContentDynamicStyle({
+      willChange: "transform",
+      transition: "transform 50ms linear"
+    });
+  }, []);
+  React2.useEffect(() => {
+    offsetRef.current = offset;
+    scheduleUpdate();
+  }, [offset]);
+  const [ioRoot, setIoRoot] = React2.useState(null);
+  React2.useEffect(() => {
+    const root = scrollRoot ?? pickDefaultScrollRoot();
+    setResolvedEdge(
+      edge === "auto" ? isVerticalScroll(root) ? "top" : "left" : edge
+    );
+    setIoRoot(root);
+  }, [edge, scrollRoot]);
+  React2.useEffect(() => {
+    if (edge !== "auto") {
+      setResolvedEdge(edge);
+      return;
+    }
+    const vertical = isVerticalScroll(ioRoot);
+    setResolvedEdge(vertical ? "top" : "left");
+  }, [edge, ioRoot]);
+  React2.useEffect(() => {
+  }, []);
+  const scheduleUpdate = () => {
+    if (rafId.current != null) return;
+    rafId.current = requestAnimationFrame(() => {
+      rafId.current = null;
+      doUpdate();
+    });
+  };
+  const doUpdate = () => {
+    if (mutatingRef.current) return;
+    mutatingRef.current = true;
+    const rootEl = rootRef.current;
+    const contentEl = contentRef.current;
+    if (!rootEl || !contentEl) {
+      mutatingRef.current = false;
+      return;
+    }
+    const parentEl = rootEl.parentElement;
+    if (!parentEl) {
+      mutatingRef.current = false;
+      return;
+    }
+    const rootBounds = ioRoot && "getBoundingClientRect" in ioRoot ? ioRoot.getBoundingClientRect() : new DOMRect(0, 0, window.innerWidth, window.innerHeight);
+    const parentRect = parentEl.getBoundingClientRect();
+    const contentRect = contentEl.getBoundingClientRect();
+    let newOffset = 0;
+    if (resolvedEdge === "top" || resolvedEdge === "bottom") {
+      const maxTranslate = Math.max(
+        0,
+        parentRect.height - contentRect.height
+      );
+      let desiredTop = 0;
+      if (resolvedEdge === "top") {
+        desiredTop = rootBounds.top + offsetRef.current - parentRect.top;
+      } else {
+        const targetBottomFromParentTop = Math.min(
+          parentRect.bottom,
+          rootBounds.bottom - offsetRef.current
+        ) - parentRect.top;
+        desiredTop = targetBottomFromParentTop - contentRect.height;
+      }
+      newOffset = clamp(desiredTop, 0, maxTranslate);
+    } else {
+      const maxTranslate = Math.max(
+        0,
+        parentRect.width - contentRect.width
+      );
+      let desiredLeft = 0;
+      if (resolvedEdge === "left") {
+        desiredLeft = rootBounds.left + offsetRef.current - parentRect.left;
+      } else {
+        const targetRightFromParentLeft = Math.min(
+          parentRect.right,
+          rootBounds.right - offsetRef.current
+        ) - parentRect.left;
+        desiredLeft = targetRightFromParentLeft - contentRect.width;
+      }
+      newOffset = clamp(desiredLeft, 0, maxTranslate);
+    }
+    const nextOffset = quantizeToDevicePixel(newOffset);
+    if (Math.abs(lastOffsetRef.current - nextOffset) > 0.5) {
+      if (resolvedEdge === "top" || resolvedEdge === "bottom") {
+        contentEl.style.transform = `translateY(${nextOffset}px)`;
+      } else {
+        contentEl.style.transform = `translateX(${nextOffset}px)`;
+      }
+      lastOffsetRef.current = nextOffset;
+      onTranslateChange(nextOffset, rootRef, contentRef);
+    }
+    if (debug) {
+      rootEl.style.outline = "1px dashed rgba(0,0,0,.2)";
+      contentEl.style.outline = "1px solid rgba(0,128,255,.35)";
+    }
+    queueMicrotask(() => {
+      mutatingRef.current = false;
+    });
+  };
+  React2.useEffect(() => {
+    if (typeof window == "undefined") return;
+    const rootEl = rootRef.current;
+    if (!rootEl) return;
+    const parentEl = rootEl.parentElement;
+    console.log(parentEl);
+    if (!parentEl) return;
+    const targets = [parentEl];
+    const observerCallback = () => {
+      if (!mutatingRef.current) scheduleUpdate();
+    };
+    const io = new IntersectionObserver(observerCallback, {
+      root: ioRoot instanceof Element ? ioRoot : null,
+      threshold: 0,
+      rootMargin: "1px"
+    });
+    const ro = new ResizeObserver(observerCallback);
+    targets.forEach((t) => io.observe(t));
+    ro.observe(parentEl);
+    if (contentRef.current) {
+      ro.observe(contentRef.current);
+    }
+    const scrollTarget = ioRoot || window;
+    scrollTarget.addEventListener("scroll", scheduleUpdate, {
+      passive: true
+    });
+    window.addEventListener("resize", scheduleUpdate);
+    scheduleUpdate();
+    return () => {
+      io.disconnect();
+      ro.disconnect();
+      scrollTarget.removeEventListener("scroll", scheduleUpdate);
+      window.removeEventListener("resize", scheduleUpdate);
+      if (rafId.current != null) {
+        cancelAnimationFrame(rafId.current);
+        rafId.current = null;
+      }
+    };
+  }, [ioRoot, resolvedEdge, offset, debug]);
+  return /* @__PURE__ */ React2__default.default.createElement(
+    "div",
+    {
+      ref: rootRef,
+      className,
+      style: {
+        display: "block",
+        minWidth: 0,
+        minHeight: 0,
+        height: "100%",
+        // 부모 높이를 채우도록 설정
+        ...style
+      },
+      ...rest
+    },
+    /* @__PURE__ */ React2__default.default.createElement(
+      "div",
+      {
+        ref: contentRef,
+        style: contentDynamicStyle
+      },
+      children
+    )
+  );
+};
+var FlexLayoutStickyBox_default = FlexLayoutStickyBox;
+var useListPagingForSentinel = ({
+  //initPageNumber,
+  //initPageSize,
+  onReachTerminal
+}) => {
+  const [firstChildNode, setFirstChildNode] = React2.useState(null);
+  const [lastChildNode, setLastChildNode] = React2.useState(null);
+  const observerRef = React2.useRef(null);
+  const firstChildRef = React2.useCallback((node) => {
+    setFirstChildNode(node);
+  }, []);
+  const lastChildRef = React2.useCallback((node) => {
+    setLastChildNode(node);
+  }, []);
+  React2.useEffect(() => {
+    if (firstChildNode && observerRef.current)
+      observerRef.current.unobserve(firstChildNode);
+    if (lastChildNode && observerRef.current)
+      observerRef.current.unobserve(lastChildNode);
+    const handleIntersect = (entries, observer2) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          if (entry.target === firstChildNode) {
+            if (onReachTerminal)
+              onReachTerminal({
+                isFirst: true,
+                isLast: false,
+                observer: observer2
+              });
+          }
+          if (entry.target === lastChildNode) {
+            if (onReachTerminal)
+              onReachTerminal({
+                isFirst: false,
+                isLast: true,
+                observer: observer2
+              });
+          }
+        }
+      });
+    };
+    const observer = new IntersectionObserver(handleIntersect, {
+      threshold: 0.1
+    });
+    observerRef.current = observer;
+    if (firstChildNode) observer.observe(firstChildNode);
+    if (lastChildNode) observer.observe(lastChildNode);
+    return () => {
+      if (observerRef.current) {
+        observerRef.current.disconnect();
+      }
+    };
+  }, [firstChildNode, lastChildNode]);
+  return {
+    firstChildRef,
+    lastChildRef
+  };
+};
+var usePaginationViewNumber = ({
+  initPageNumber
+}) => {
+  const [showCurrentPageNumber, setShowCurrentPageNumber] = React2.useState(initPageNumber);
+  const observerRef = React2.useRef(null);
+  const showCurrentPageObserveTarget = React2.useCallback(
+    (node) => {
+      if (!node) return;
+      if (!observerRef.current) {
+        observerRef.current = new IntersectionObserver(
+          (entries) => {
+            entries.forEach((entry) => {
+              if (entry.isIntersecting) {
+                const pageIndexAttr = entry.target.getAttribute(
+                  "data-page-index"
+                );
+                if (!pageIndexAttr) return;
+                const pageIndex = parseInt(pageIndexAttr, 10);
+                setShowCurrentPageNumber(pageIndex);
+              }
+            });
+          },
+          {
+            threshold: 0.1
+            // 예: 10% 이상 보여야 intersect로 판단
+          }
+        );
+      }
+      observerRef.current.observe(node);
+    },
+    []
+  );
+  React2.useEffect(() => {
+    const currentObserver = observerRef.current;
+    return () => {
+      if (currentObserver) {
+        currentObserver.disconnect();
+      }
+    };
+  }, []);
+  return {
+    showCurrentPageNumber,
+    showCurrentPageObserveTarget
+  };
+};
+var usePagingHandler = ({
+  lastCallPageNumber,
+  dataListRef
+}) => {
+  const jumpingPageNumberRef = React2.useRef(lastCallPageNumber);
+  React2.useEffect(() => {
+    if (jumpingPageNumberRef.current) {
+      setTimeout(() => {
+        jumpingPageNumberRef.current = null;
+      }, 1e3);
+    }
+  }, [jumpingPageNumberRef]);
+  const paginationScrollIntoViewTarget = React2.useRef({});
+  const pageNumberRef = React2.useRef(lastCallPageNumber);
+  const setPaginationRef = React2.useCallback(
+    (i) => (node) => {
+      if (!node) return;
+      paginationScrollIntoViewTarget.current[i] = node;
+      if (jumpingPageNumberRef.current !== null && i === jumpingPageNumberRef.current) {
+        node.scrollIntoView({
+          behavior: "instant",
+          // 필요한 경우 'smooth' 등으로 수정 가능
+          block: "start"
+        });
+        jumpingPageNumberRef.current = null;
+      }
+    },
+    []
+  );
+  const handleReachTerminal = ({ isFirst, isLast, observer }, dataCallFetch) => {
+    if (dataListRef.current.length === 0) return;
+    if (jumpingPageNumberRef.current != null) return;
+    if (!isFirst && !isLast) return;
+    const callPageNumber = isFirst ? Math.max(pageNumberRef.current - 1, 0) : pageNumberRef.current + 1;
+    if (dataListRef.current[callPageNumber] != null && (dataListRef.current[callPageNumber]?.length || 0) > 0)
+      return;
+    jumpingPageNumberRef.current = callPageNumber;
+    setTimeout(() => {
+      jumpingPageNumberRef.current = null;
+    }, 1e3);
+    dataCallFetch(callPageNumber);
+  };
+  const handleClickPageChange = (page, dataCallFetch) => {
+    const pageData = dataListRef.current[page];
+    if (pageData != null && Array.isArray(pageData) && pageData.length > 0) {
+      paginationScrollIntoViewTarget.current[page]?.scrollIntoView({
+        behavior: "smooth",
+        block: "start"
+      });
+      return;
+    }
+    jumpingPageNumberRef.current = page;
+    setTimeout(() => {
+      jumpingPageNumberRef.current = null;
+    }, 1e3);
+    dataCallFetch(page);
+  };
+  return {
+    jumpingPageNumberRef,
+    paginationScrollIntoViewTarget,
+    pageNumberRef,
+    setPaginationRef,
+    handleReachTerminal,
+    handleClickPageChange
+  };
+};
+
+exports.ContainerOpenCloseProvider = ContainerOpenCloseProvider;
+exports.FlexLayout = FlexLayout;
+exports.FlexLayoutContainer = FlexLayoutContainer;
+exports.FlexLayoutResizePanel = FlexLayoutResizePanel;
+exports.FlexLayoutSplitScreen = FlexLayoutSplitScreen;
+exports.FlexLayoutSplitScreenDragBox = FlexLayoutSplitScreenDragBox;
+exports.FlexLayoutSplitScreenScrollBox = FlexLayoutSplitScreenScrollBox_default;
+exports.FlexLayoutStickyBox = FlexLayoutStickyBox_default;
+exports.allSplitScreenCount = allSplitScreenCount;
+exports.closeFlex = closeFlex;
+exports.containerOpenCloseSubjectMap = containerOpenCloseSubjectMap;
+exports.containerSpreadSubjectMap = containerSpreadSubjectMap;
+exports.dragState = dragState;
+exports.dropMovementEventSubject = dropMovementEventSubject;
+exports.findNotCloseFlexContent = findNotCloseFlexContent;
+exports.flexContainerStore = flexContainerStore;
+exports.flexResizePanelStore = flexResizePanelStore;
+exports.folderEventSubject = folderEventSubject;
+exports.getClientXy = getClientXy;
+exports.getContainerRef = getContainerRef;
+exports.getCurrentSplitScreenComponents = getCurrentSplitScreenComponents;
+exports.getGrow = getGrow;
+exports.getLayoutInfos = getLayoutInfos;
+exports.getResizePanelRef = getResizePanelRef;
+exports.getScrollPosition = getScrollPosition;
+exports.getSplitScreen = getSplitScreen;
+exports.isDocumentOut = isDocumentOut;
+exports.isOverMove = isOverMove;
+exports.layoutSplitScreenStore = layoutSplitScreenStore;
+exports.mathGrow = mathGrow;
+exports.mathWeight = mathWeight;
+exports.openFlex = openFlex;
+exports.remain = remain;
+exports.removeScrollPosition = removeScrollPosition;
+exports.removeSplitScreenChild = removeSplitScreenChild;
+exports.resetRootSplitScreen = resetRootSplitScreen;
+exports.resize = resize;
+exports.scrollPositions = scrollPositions;
+exports.setContainerRef = setContainerRef;
+exports.setFolderEvent = setFolderEvent;
+exports.setResizePanelRef = setResizePanelRef;
+exports.setScrollPosition = setScrollPosition;
+exports.setSplitScreen = setSplitScreen;
+exports.useContainerSize = useContainerSize;
+exports.useContainers = useContainers;
+exports.useDecompositionLayout = useDecompositionLayout;
+exports.useDoubleClick = useDoubleClick;
+exports.useDragCapture = useDragCapture;
+exports.useDragEvents = useDragEvents;
+exports.useFolderEvent = useFolderEvent;
+exports.useLayoutName = useLayoutName;
+exports.useListPagingForSentinel = useListPagingForSentinel;
+exports.usePaginationViewNumber = usePaginationViewNumber;
+exports.usePagingHandler = usePagingHandler;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map