@opengovsg/oui 0.0.0-snapshot-20250813090518 → 0.0.0-snapshot-20250813172831

package/dist/esm/node_modules/.pnpm/@react-aria_interactions@3.25.3_react-dom@19.0.0_react@19.0.0__react@19.0.0/node_modules/@react-aria/interactions/dist/utils.js

@@ -0,0 +1,155 @@
+import { isFocusable, getOwnerWindow, focusWithoutScrolling, useLayoutEffect, useEffectEvent } from '@react-aria/utils';
+import { useRef, useCallback } from 'react';
+
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+function $8a9cb279dc87e130$export$525bc4921d56d4a(nativeEvent) {
+    let event = nativeEvent;
+    event.nativeEvent = nativeEvent;
+    event.isDefaultPrevented = ()=>event.defaultPrevented;
+    // cancelBubble is technically deprecated in the spec, but still supported in all browsers.
+    event.isPropagationStopped = ()=>event.cancelBubble;
+    event.persist = ()=>{};
+    return event;
+}
+function $8a9cb279dc87e130$export$c2b7abe5d61ec696(event, target) {
+    Object.defineProperty(event, 'target', {
+        value: target
+    });
+    Object.defineProperty(event, 'currentTarget', {
+        value: target
+    });
+}
+function $8a9cb279dc87e130$export$715c682d09d639cc(onBlur) {
+    let stateRef = (useRef)({
+        isFocused: false,
+        observer: null
+    });
+    // Clean up MutationObserver on unmount. See below.
+    (useLayoutEffect)(()=>{
+        const state = stateRef.current;
+        return ()=>{
+            if (state.observer) {
+                state.observer.disconnect();
+                state.observer = null;
+            }
+        };
+    }, []);
+    let dispatchBlur = (useEffectEvent)((e)=>{
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur(e);
+    });
+    // This function is called during a React onFocus event.
+    return (useCallback)((e)=>{
+        // React does not fire onBlur when an element is disabled. https://github.com/facebook/react/issues/9142
+        // Most browsers fire a native focusout event in this case, except for Firefox. In that case, we use a
+        // MutationObserver to watch for the disabled attribute, and dispatch these events ourselves.
+        // For browsers that do, focusout fires before the MutationObserver, so onBlur should not fire twice.
+        if (e.target instanceof HTMLButtonElement || e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) {
+            stateRef.current.isFocused = true;
+            let target = e.target;
+            let onBlurHandler = (e)=>{
+                stateRef.current.isFocused = false;
+                if (target.disabled) {
+                    // For backward compatibility, dispatch a (fake) React synthetic event.
+                    let event = $8a9cb279dc87e130$export$525bc4921d56d4a(e);
+                    dispatchBlur(event);
+                }
+                // We no longer need the MutationObserver once the target is blurred.
+                if (stateRef.current.observer) {
+                    stateRef.current.observer.disconnect();
+                    stateRef.current.observer = null;
+                }
+            };
+            target.addEventListener('focusout', onBlurHandler, {
+                once: true
+            });
+            stateRef.current.observer = new MutationObserver(()=>{
+                if (stateRef.current.isFocused && target.disabled) {
+                    var _stateRef_current_observer;
+                    (_stateRef_current_observer = stateRef.current.observer) === null || _stateRef_current_observer === void 0 ? void 0 : _stateRef_current_observer.disconnect();
+                    let relatedTargetEl = target === document.activeElement ? null : document.activeElement;
+                    target.dispatchEvent(new FocusEvent('blur', {
+                        relatedTarget: relatedTargetEl
+                    }));
+                    target.dispatchEvent(new FocusEvent('focusout', {
+                        bubbles: true,
+                        relatedTarget: relatedTargetEl
+                    }));
+                }
+            });
+            stateRef.current.observer.observe(target, {
+                attributes: true,
+                attributeFilter: [
+                    'disabled'
+                ]
+            });
+        }
+    }, [
+        dispatchBlur
+    ]);
+}
+let $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
+function $8a9cb279dc87e130$export$cabe61c495ee3649(target) {
+    // The browser will focus the nearest focusable ancestor of our target.
+    while(target && !(isFocusable)(target))target = target.parentElement;
+    let window = (getOwnerWindow)(target);
+    let activeElement = window.document.activeElement;
+    if (!activeElement || activeElement === target) return;
+    $8a9cb279dc87e130$export$fda7da73ab5d4c48 = true;
+    let isRefocusing = false;
+    let onBlur = (e)=>{
+        if (e.target === activeElement || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusOut = (e)=>{
+        if (e.target === activeElement || isRefocusing) {
+            e.stopImmediatePropagation();
+            // If there was no focusable ancestor, we don't expect a focus event.
+            // Re-focus the original active element here.
+            if (!target && !isRefocusing) {
+                isRefocusing = true;
+                (focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    let onFocus = (e)=>{
+        if (e.target === target || isRefocusing) e.stopImmediatePropagation();
+    };
+    let onFocusIn = (e)=>{
+        if (e.target === target || isRefocusing) {
+            e.stopImmediatePropagation();
+            if (!isRefocusing) {
+                isRefocusing = true;
+                (focusWithoutScrolling)(activeElement);
+                cleanup();
+            }
+        }
+    };
+    window.addEventListener('blur', onBlur, true);
+    window.addEventListener('focusout', onFocusOut, true);
+    window.addEventListener('focusin', onFocusIn, true);
+    window.addEventListener('focus', onFocus, true);
+    let cleanup = ()=>{
+        cancelAnimationFrame(raf);
+        window.removeEventListener('blur', onBlur, true);
+        window.removeEventListener('focusout', onFocusOut, true);
+        window.removeEventListener('focusin', onFocusIn, true);
+        window.removeEventListener('focus', onFocus, true);
+        $8a9cb279dc87e130$export$fda7da73ab5d4c48 = false;
+        isRefocusing = false;
+    };
+    let raf = requestAnimationFrame(cleanup);
+    return cleanup;
+}
+
+export { $8a9cb279dc87e130$export$525bc4921d56d4a as createSyntheticEvent, $8a9cb279dc87e130$export$fda7da73ab5d4c48 as ignoreFocusEvent, $8a9cb279dc87e130$export$cabe61c495ee3649 as preventFocus, $8a9cb279dc87e130$export$c2b7abe5d61ec696 as setEventTarget, $8a9cb279dc87e130$export$715c682d09d639cc as useSyntheticBlurEvent };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_check_private_redeclaration.js

@@ -0,0 +1,7 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+
+export { _check_private_redeclaration as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_apply_descriptor_get.js

@@ -0,0 +1,7 @@
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+
+    return descriptor.value;
+}
+
+export { _class_apply_descriptor_get as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_apply_descriptor_set.js

@@ -0,0 +1,14 @@
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) {
+            // This should only throw in strict mode, but class bodies are
+            // always strict and private fields can only be used inside
+            // class bodies.
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+
+export { _class_apply_descriptor_set as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_extract_field_descriptor.js

@@ -0,0 +1,7 @@
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+
+    return privateMap.get(receiver);
+}
+
+export { _class_extract_field_descriptor as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_get.js

@@ -0,0 +1,9 @@
+import { _ as _class_apply_descriptor_get } from './_class_apply_descriptor_get.js';
+import { _ as _class_extract_field_descriptor } from './_class_extract_field_descriptor.js';
+
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+
+export { _class_private_field_get as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_init.js

@@ -0,0 +1,8 @@
+import { _ as _check_private_redeclaration } from './_check_private_redeclaration.js';
+
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+
+export { _class_private_field_init as _ };

package/dist/esm/node_modules/.pnpm/@swc_helpers@0.5.17/node_modules/@swc/helpers/esm/_class_private_field_set.js

@@ -0,0 +1,10 @@
+import { _ as _class_apply_descriptor_set } from './_class_apply_descriptor_set.js';
+import { _ as _class_extract_field_descriptor } from './_class_extract_field_descriptor.js';
+
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+
+export { _class_private_field_set as _ };

package/dist/esm/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevrons-right.js

@@ -0,0 +1,17 @@
+import createLucideIcon from '../createLucideIcon.js';
+
+/**
+ * @license lucide-react v0.475.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+
+const __iconNode = [
+  ["path", { d: "m6 17 5-5-5-5", key: "xnjwq" }],
+  ["path", { d: "m13 17 5-5-5-5", key: "17xmmf" }]
+];
+const ChevronsRight = createLucideIcon("ChevronsRight", __iconNode);
+
+export { __iconNode, ChevronsRight as default };

package/dist/esm/node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/ellipsis.js

@@ -0,0 +1,18 @@
+import createLucideIcon from '../createLucideIcon.js';
+
+/**
+ * @license lucide-react v0.475.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+
+const __iconNode = [
+  ["circle", { cx: "12", cy: "12", r: "1", key: "41hilf" }],
+  ["circle", { cx: "19", cy: "12", r: "1", key: "1wjl8i" }],
+  ["circle", { cx: "5", cy: "12", r: "1", key: "1pcz8c" }]
+];
+const Ellipsis = createLucideIcon("Ellipsis", __iconNode);
+
+export { __iconNode, Ellipsis as default };

package/dist/esm/pagination/hooks/use-pagination.js

@@ -0,0 +1,114 @@
+"use strict";
+"use client";
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { useLocale } from '@react-aria/i18n';
+
+var PaginationItemType = /* @__PURE__ */ ((PaginationItemType2) => {
+  PaginationItemType2["DOTS"] = "dots";
+  PaginationItemType2["PREV"] = "prev";
+  PaginationItemType2["NEXT"] = "next";
+  return PaginationItemType2;
+})(PaginationItemType || {});
+function range(start, end) {
+  const length = end - start + 1;
+  return Array.from({ length }, (_, index) => index + start);
+}
+function usePagination(props) {
+  const {
+    page,
+    total,
+    siblings = 1,
+    boundaries = 1,
+    initialPage = 1,
+    showControls = false,
+    onChange
+  } = props;
+  const [activePage, setActivePage] = useState(page || initialPage);
+  const { direction } = useLocale();
+  const isRTL = direction === "rtl";
+  const onChangeActivePage = useCallback(
+    (newPage) => {
+      setActivePage(newPage);
+      onChange?.(newPage);
+    },
+    [onChange]
+  );
+  useEffect(() => {
+    if (page && page !== activePage) {
+      setActivePage(page);
+    }
+  }, [activePage, page]);
+  const setPage = useCallback(
+    (pageNumber) => {
+      if (pageNumber <= 0) {
+        onChangeActivePage(1);
+      } else if (pageNumber > total) {
+        onChangeActivePage(total);
+      } else {
+        onChangeActivePage(pageNumber);
+      }
+    },
+    [total, onChangeActivePage]
+  );
+  const next = () => setPage(activePage + 1);
+  const previous = () => setPage(activePage - 1);
+  const first = () => setPage(1);
+  const last = () => setPage(total);
+  const formatRange = useCallback(
+    (range2) => {
+      if (showControls) {
+        return ["prev" /* PREV */, ...range2, "next" /* NEXT */];
+      }
+      return range2;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [isRTL, showControls]
+  );
+  const paginationRange = useMemo(() => {
+    const totalPageNumbers = siblings * 2 + 3 + boundaries * 2;
+    if (totalPageNumbers >= total) {
+      return formatRange(range(1, total));
+    }
+    const leftSiblingIndex = Math.max(activePage - siblings, boundaries);
+    const rightSiblingIndex = Math.min(
+      activePage + siblings,
+      total - boundaries
+    );
+    const shouldShowLeftDots = leftSiblingIndex > boundaries + 2;
+    const shouldShowRightDots = rightSiblingIndex < total - (boundaries + 1);
+    if (!shouldShowLeftDots && shouldShowRightDots) {
+      const leftItemCount = siblings * 2 + boundaries + 2;
+      return formatRange([
+        ...range(1, leftItemCount),
+        "dots" /* DOTS */,
+        ...range(total - (boundaries - 1), total)
+      ]);
+    }
+    if (shouldShowLeftDots && !shouldShowRightDots) {
+      const rightItemCount = boundaries + 1 + 2 * siblings;
+      return formatRange([
+        ...range(1, boundaries),
+        "dots" /* DOTS */,
+        ...range(total - rightItemCount, total)
+      ]);
+    }
+    return formatRange([
+      ...range(1, boundaries),
+      "dots" /* DOTS */,
+      ...range(leftSiblingIndex, rightSiblingIndex),
+      "dots" /* DOTS */,
+      ...range(total - boundaries + 1, total)
+    ]);
+  }, [total, activePage, siblings, boundaries, formatRange]);
+  return {
+    range: paginationRange,
+    activePage,
+    setPage,
+    next,
+    previous,
+    first,
+    last
+  };
+}
+
+export { PaginationItemType, usePagination };

package/dist/esm/pagination/index.js

@@ -0,0 +1,6 @@
+"use strict";
+export { Pagination } from './pagination.js';
+export { PaginationCursor } from './pagination-cursor.js';
+export { PaginationItem } from './pagination-item.js';
+export { PaginationItemType } from './hooks/use-pagination.js';
+export { CURSOR_TRANSITION_TIMEOUT, usePagination } from './use-pagination.js';

package/dist/esm/pagination/pagination-cursor.js

@@ -0,0 +1,16 @@
+"use strict";
+"use client";
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef } from '../system/utils.js';
+import { useDomRef } from '../system/react-utils/refs.js';
+
+const PaginationCursor = forwardRef(
+  (props, ref) => {
+    const { as, activePage, ...otherProps } = props;
+    const Component = as || "span";
+    const domRef = useDomRef(ref);
+    return /* @__PURE__ */ jsx(Component, { ref: domRef, "aria-hidden": true, ...otherProps, children: activePage });
+  }
+);
+
+export { PaginationCursor };

package/dist/esm/pagination/pagination-item.js

@@ -0,0 +1,16 @@
+"use strict";
+import { jsx } from 'react/jsx-runtime';
+import { forwardRef } from '../system/utils.js';
+import { usePaginationItem } from './use-pagination-item.js';
+
+const PaginationItem = forwardRef(
+  (props, ref) => {
+    const { Component, children, getItemProps } = usePaginationItem({
+      ...props,
+      ref
+    });
+    return /* @__PURE__ */ jsx(Component, { ...getItemProps(), children });
+  }
+);
+
+export { PaginationItem };

package/dist/esm/pagination/pagination.js

@@ -0,0 +1,261 @@
+"use strict";
+"use client";
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { useCallback, createElement } from 'react';
+import { useLocale } from '@react-aria/i18n';
+import { cn, dataAttr } from '@opengovsg/oui-theme';
+import { forwardRef } from '../system/utils.js';
+import { PaginationItemType } from './hooks/use-pagination.js';
+import { PaginationCursor } from './pagination-cursor.js';
+import { PaginationItem } from './pagination-item.js';
+import { usePagination } from './use-pagination.js';
+import ChevronLeft from '../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevron-left.js';
+import Ellipsis from '../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/ellipsis.js';
+import ChevronsRight from '../node_modules/.pnpm/lucide-react@0.475.0_react@19.0.0/node_modules/lucide-react/dist/esm/icons/chevrons-right.js';
+
+const Pagination = forwardRef((props, ref) => {
+  const {
+    Component,
+    dotsJump,
+    slots,
+    classNames,
+    total,
+    range,
+    loop,
+    activePage,
+    disableCursorAnimation,
+    disableAnimation,
+    renderItem: renderItemProp,
+    onNext,
+    onPrevious,
+    setPage,
+    getItemAriaLabel,
+    getItemRef,
+    getBaseProps,
+    getWrapperProps,
+    getItemProps,
+    getCursorProps
+  } = usePagination({ ...props, ref });
+  const { direction } = useLocale();
+  const isRTL = direction === "rtl";
+  const renderChevronIcon = useCallback(
+    (key) => {
+      if (key === PaginationItemType.PREV && !isRTL || key === PaginationItemType.NEXT && isRTL) {
+        return /* @__PURE__ */ jsx(ChevronLeft, {});
+      }
+      return /* @__PURE__ */ jsx(
+        ChevronLeft,
+        {
+          className: slots.chevronNext({
+            class: classNames?.chevronNext
+          })
+        }
+      );
+    },
+    [isRTL, slots, classNames?.chevronNext]
+  );
+  const renderPrevItem = useCallback(() => {
+    return /* @__PURE__ */ jsx(
+      PaginationItem,
+      {
+        className: slots.prev({
+          class: classNames?.prev
+        }),
+        "data-slot": "prev",
+        getAriaLabel: getItemAriaLabel,
+        isDisabled: props.isDisabled || !loop && activePage === 1,
+        value: PaginationItemType.PREV,
+        onPress: onPrevious,
+        children: renderChevronIcon(PaginationItemType.PREV)
+      },
+      PaginationItemType.PREV
+    );
+  }, [
+    slots,
+    classNames?.prev,
+    getItemAriaLabel,
+    props.isDisabled,
+    loop,
+    activePage,
+    onPrevious,
+    renderChevronIcon
+  ]);
+  const renderNextItem = useCallback(() => {
+    return /* @__PURE__ */ jsx(
+      PaginationItem,
+      {
+        className: slots.next({
+          class: cn(classNames?.next)
+        }),
+        "data-slot": "next",
+        getAriaLabel: getItemAriaLabel,
+        isDisabled: props.isDisabled || !loop && activePage === total,
+        value: PaginationItemType.NEXT,
+        onPress: onNext,
+        children: renderChevronIcon(PaginationItemType.NEXT)
+      },
+      PaginationItemType.NEXT
+    );
+  }, [
+    slots,
+    classNames?.next,
+    getItemAriaLabel,
+    props.isDisabled,
+    loop,
+    activePage,
+    total,
+    onNext,
+    renderChevronIcon
+  ]);
+  const renderItem = useCallback(
+    (value, index) => {
+      const isBefore = index < range.indexOf(activePage);
+      if (renderItemProp && typeof renderItemProp === "function") {
+        let page = typeof value == "number" ? value : index;
+        if (value === PaginationItemType.NEXT) {
+          page = activePage + 1;
+        }
+        if (value === PaginationItemType.PREV) {
+          page = activePage - 1;
+        }
+        if (value === PaginationItemType.DOTS) {
+          page = isBefore ? activePage - dotsJump >= 1 ? activePage - dotsJump : 1 : activePage + dotsJump <= total ? activePage + dotsJump : total;
+        }
+        const itemChildren = {
+          [PaginationItemType.PREV]: renderChevronIcon(PaginationItemType.PREV),
+          [PaginationItemType.NEXT]: renderChevronIcon(PaginationItemType.NEXT),
+          [PaginationItemType.DOTS]: /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Ellipsis,
+              {
+                className: slots?.ellipsis({ class: classNames?.ellipsis })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ChevronsRight,
+              {
+                className: slots?.forwardIcon({
+                  class: classNames?.forwardIcon
+                }),
+                "data-before": dataAttr(isBefore)
+              }
+            )
+          ] })
+        };
+        return renderItemProp({
+          value,
+          index,
+          key: `${value}-${index}`,
+          page,
+          total,
+          children: typeof value === "number" ? value : itemChildren[value],
+          activePage,
+          dotsJump,
+          isBefore,
+          isActive: value === activePage,
+          isPrevious: value === activePage - 1,
+          isNext: value === activePage + 1,
+          isFirst: value === 1,
+          isLast: value === total,
+          onNext,
+          onPrevious,
+          setPage,
+          onPress: () => setPage(page),
+          ref: typeof value === "number" ? (node) => getItemRef(node, value) : void 0,
+          className: slots.item({ class: classNames?.item }),
+          getAriaLabel: getItemAriaLabel
+        });
+      }
+      if (value === PaginationItemType.PREV) {
+        return renderPrevItem();
+      }
+      if (value === PaginationItemType.NEXT) {
+        return renderNextItem();
+      }
+      if (value === PaginationItemType.DOTS) {
+        return /* @__PURE__ */ jsxs(
+          PaginationItem,
+          {
+            className: slots.item({
+              class: cn(classNames?.item, "group")
+            }),
+            isDisabled: props.isDisabled,
+            "data-slot": "item",
+            getAriaLabel: getItemAriaLabel,
+            value,
+            onPress: () => isBefore ? setPage(
+              activePage - dotsJump >= 1 ? activePage - dotsJump : 1
+            ) : setPage(
+              activePage + dotsJump <= total ? activePage + dotsJump : total
+            ),
+            children: [
+              /* @__PURE__ */ jsx(
+                Ellipsis,
+                {
+                  className: slots?.ellipsis({ class: classNames?.ellipsis })
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                ChevronsRight,
+                {
+                  className: slots?.forwardIcon({ class: classNames?.forwardIcon }),
+                  "data-before": dataAttr(isRTL ? !isBefore : isBefore)
+                }
+              )
+            ]
+          },
+          PaginationItemType.DOTS + isBefore
+        );
+      }
+      return /* @__PURE__ */ createElement(
+        PaginationItem,
+        {
+          ...getItemProps({ value }),
+          key: value,
+          getAriaLabel: getItemAriaLabel
+        },
+        value
+      );
+    },
+    [
+      range,
+      activePage,
+      renderItemProp,
+      getItemProps,
+      getItemAriaLabel,
+      renderChevronIcon,
+      slots,
+      classNames?.ellipsis,
+      classNames?.forwardIcon,
+      classNames?.item,
+      total,
+      dotsJump,
+      onNext,
+      onPrevious,
+      setPage,
+      getItemRef,
+      renderPrevItem,
+      renderNextItem,
+      props.isDisabled,
+      isRTL
+    ]
+  );
+  if (props.isCompact) {
+    return /* @__PURE__ */ jsx(Component, { ...getBaseProps(), children: /* @__PURE__ */ jsxs("ul", { ...getWrapperProps(), children: [
+      renderPrevItem(),
+      /* @__PURE__ */ jsxs("li", { className: slots.item({ class: classNames?.item }), children: [
+        "Page ",
+        activePage,
+        " of ",
+        total
+      ] }),
+      renderNextItem()
+    ] }) });
+  }
+  return /* @__PURE__ */ jsx(Component, { ...getBaseProps(), children: /* @__PURE__ */ jsxs("ul", { ...getWrapperProps(), children: [
+    !disableCursorAnimation && !disableAnimation && /* @__PURE__ */ jsx(PaginationCursor, { ...getCursorProps() }),
+    range.map(renderItem)
+  ] }) });
+});
+
+export { Pagination };