@t-headless-ui/react 1.1.2 → 1.1.4

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/index.mjs

@@ -0,0 +1,215 @@
+import { time as n } from "../frameloop/sync-time.mjs";
+import { frame as d } from "../frameloop/frame.mjs";
+import { warnOnce as c } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/warn-once.mjs";
+import { SubscriptionManager as p } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/subscription-manager.mjs";
+import { velocityPerSecond as u } from "../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/velocity-per-second.mjs";
+const a = 30, f = (s) => !isNaN(parseFloat(s));
+class l {
+  /**
+   * @param init - The initiating value
+   * @param config - Optional configuration options
+   *
+   * -  `transformer`: A function to transform incoming values with.
+   */
+  constructor(t, e = {}) {
+    this.canTrackVelocity = null, this.events = {}, this.updateAndNotify = (i) => {
+      var r;
+      const h = n.now();
+      if (this.updatedAt !== h && this.setPrevFrameValue(), this.prev = this.current, this.setCurrent(i), this.current !== this.prev && ((r = this.events.change) == null || r.notify(this.current), this.dependents))
+        for (const o of this.dependents)
+          o.dirty();
+    }, this.hasAnimated = !1, this.setCurrent(t), this.owner = e.owner;
+  }
+  setCurrent(t) {
+    this.current = t, this.updatedAt = n.now(), this.canTrackVelocity === null && t !== void 0 && (this.canTrackVelocity = f(this.current));
+  }
+  setPrevFrameValue(t = this.current) {
+    this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt;
+  }
+  /**
+   * Adds a function that will be notified when the `MotionValue` is updated.
+   *
+   * It returns a function that, when called, will cancel the subscription.
+   *
+   * When calling `onChange` inside a React component, it should be wrapped with the
+   * `useEffect` hook. As it returns an unsubscribe function, this should be returned
+   * from the `useEffect` function to ensure you don't add duplicate subscribers..
+   *
+   * ```jsx
+   * export const MyComponent = () => {
+   *   const x = useMotionValue(0)
+   *   const y = useMotionValue(0)
+   *   const opacity = useMotionValue(1)
+   *
+   *   useEffect(() => {
+   *     function updateOpacity() {
+   *       const maxXY = Math.max(x.get(), y.get())
+   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])
+   *       opacity.set(newOpacity)
+   *     }
+   *
+   *     const unsubscribeX = x.on("change", updateOpacity)
+   *     const unsubscribeY = y.on("change", updateOpacity)
+   *
+   *     return () => {
+   *       unsubscribeX()
+   *       unsubscribeY()
+   *     }
+   *   }, [])
+   *
+   *   return <motion.div style={{ x }} />
+   * }
+   * ```
+   *
+   * @param subscriber - A function that receives the latest value.
+   * @returns A function that, when called, will cancel this subscription.
+   *
+   * @deprecated
+   */
+  onChange(t) {
+    return process.env.NODE_ENV !== "production" && c(!1, 'value.onChange(callback) is deprecated. Switch to value.on("change", callback).'), this.on("change", t);
+  }
+  on(t, e) {
+    this.events[t] || (this.events[t] = new p());
+    const i = this.events[t].add(e);
+    return t === "change" ? () => {
+      i(), d.read(() => {
+        this.events.change.getSize() || this.stop();
+      });
+    } : i;
+  }
+  clearListeners() {
+    for (const t in this.events)
+      this.events[t].clear();
+  }
+  /**
+   * Attaches a passive effect to the `MotionValue`.
+   */
+  attach(t, e) {
+    this.passiveEffect = t, this.stopPassiveEffect = e;
+  }
+  /**
+   * Sets the state of the `MotionValue`.
+   *
+   * @remarks
+   *
+   * ```jsx
+   * const x = useMotionValue(0)
+   * x.set(10)
+   * ```
+   *
+   * @param latest - Latest value to set.
+   * @param render - Whether to notify render subscribers. Defaults to `true`
+   *
+   * @public
+   */
+  set(t) {
+    this.passiveEffect ? this.passiveEffect(t, this.updateAndNotify) : this.updateAndNotify(t);
+  }
+  setWithVelocity(t, e, i) {
+    this.set(e), this.prev = void 0, this.prevFrameValue = t, this.prevUpdatedAt = this.updatedAt - i;
+  }
+  /**
+   * Set the state of the `MotionValue`, stopping any active animations,
+   * effects, and resets velocity to `0`.
+   */
+  jump(t, e = !0) {
+    this.updateAndNotify(t), this.prev = t, this.prevUpdatedAt = this.prevFrameValue = void 0, e && this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+  dirty() {
+    var t;
+    (t = this.events.change) == null || t.notify(this.current);
+  }
+  addDependent(t) {
+    this.dependents || (this.dependents = /* @__PURE__ */ new Set()), this.dependents.add(t);
+  }
+  removeDependent(t) {
+    this.dependents && this.dependents.delete(t);
+  }
+  /**
+   * Returns the latest state of `MotionValue`
+   *
+   * @returns - The latest state of `MotionValue`
+   *
+   * @public
+   */
+  get() {
+    return this.current;
+  }
+  /**
+   * @public
+   */
+  getPrevious() {
+    return this.prev;
+  }
+  /**
+   * Returns the latest velocity of `MotionValue`
+   *
+   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.
+   *
+   * @public
+   */
+  getVelocity() {
+    const t = n.now();
+    if (!this.canTrackVelocity || this.prevFrameValue === void 0 || t - this.updatedAt > a)
+      return 0;
+    const e = Math.min(this.updatedAt - this.prevUpdatedAt, a);
+    return u(parseFloat(this.current) - parseFloat(this.prevFrameValue), e);
+  }
+  /**
+   * Registers a new animation to control this `MotionValue`. Only one
+   * animation can drive a `MotionValue` at one time.
+   *
+   * ```jsx
+   * value.start()
+   * ```
+   *
+   * @param animation - A function that starts the provided animation
+   */
+  start(t) {
+    return this.stop(), new Promise((e) => {
+      this.hasAnimated = !0, this.animation = t(e), this.events.animationStart && this.events.animationStart.notify();
+    }).then(() => {
+      this.events.animationComplete && this.events.animationComplete.notify(), this.clearAnimation();
+    });
+  }
+  /**
+   * Stop the currently active animation.
+   *
+   * @public
+   */
+  stop() {
+    this.animation && (this.animation.stop(), this.events.animationCancel && this.events.animationCancel.notify()), this.clearAnimation();
+  }
+  /**
+   * Returns `true` if this value is currently animating.
+   *
+   * @public
+   */
+  isAnimating() {
+    return !!this.animation;
+  }
+  clearAnimation() {
+    delete this.animation;
+  }
+  /**
+   * Destroy and clean up subscribers to this `MotionValue`.
+   *
+   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically
+   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually
+   * created a `MotionValue` via the `motionValue` function.
+   *
+   * @public
+   */
+  destroy() {
+    var t, e;
+    (t = this.dependents) == null || t.clear(), (e = this.events.destroy) == null || e.notify(), this.clearListeners(), this.stop(), this.stopPassiveEffect && this.stopPassiveEffect();
+  }
+}
+function g(s, t) {
+  return new l(s, t);
+}
+export {
+  l as MotionValue,
+  g as motionValue
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/color/hsla.mjs

@@ -0,0 +1,12 @@
+import { alpha as n } from "../numbers/index.mjs";
+import { percent as t } from "../numbers/units.mjs";
+import { sanitize as r } from "../utils/sanitize.mjs";
+import { splitColor as i, isColorString as e } from "./utils.mjs";
+const u = {
+  test: /* @__PURE__ */ e("hsl", "hue"),
+  parse: /* @__PURE__ */ i("hue", "saturation", "lightness"),
+  transform: ({ hue: o, saturation: s, lightness: a, alpha: m = 1 }) => "hsla(" + Math.round(o) + ", " + t.transform(r(s)) + ", " + t.transform(r(a)) + ", " + r(n.transform(m)) + ")"
+};
+export {
+  u as hsla
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/color/index.mjs

@@ -0,0 +1,15 @@
+import { hex as o } from "./hex.mjs";
+import { hsla as t } from "./hsla.mjs";
+import { rgba as e } from "./rgba.mjs";
+const a = {
+  test: (r) => e.test(r) || o.test(r) || t.test(r),
+  parse: (r) => e.test(r) ? e.parse(r) : t.test(r) ? t.parse(r) : o.parse(r),
+  transform: (r) => typeof r == "string" ? r : r.hasOwnProperty("red") ? e.transform(r) : t.transform(r),
+  getAnimatableNone: (r) => {
+    const s = a.parse(r);
+    return s.alpha = 0, a.transform(s);
+  }
+};
+export {
+  a as color
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/color/rgba.mjs

@@ -0,0 +1,16 @@
+import { number as n, alpha as s } from "../numbers/index.mjs";
+import { sanitize as i } from "../utils/sanitize.mjs";
+import { splitColor as p, isColorString as e } from "./utils.mjs";
+import { clamp as f } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+const l = (r) => f(0, 255, r), o = {
+  ...n,
+  transform: (r) => Math.round(l(r))
+}, h = {
+  test: /* @__PURE__ */ e("rgb", "red"),
+  parse: /* @__PURE__ */ p("red", "green", "blue"),
+  transform: ({ red: r, green: t, blue: a, alpha: m = 1 }) => "rgba(" + o.transform(r) + ", " + o.transform(t) + ", " + o.transform(a) + ", " + i(s.transform(m)) + ")"
+};
+export {
+  o as rgbUnit,
+  h as rgba
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/complex/index.mjs

@@ -0,0 +1,49 @@
+import { color as u } from "../color/index.mjs";
+import { colorRegex as N } from "../utils/color-regex.mjs";
+import { floatRegex as d } from "../utils/float-regex.mjs";
+import { sanitize as b } from "../utils/sanitize.mjs";
+function x(t) {
+  var o, e;
+  return isNaN(t) && typeof t == "string" && (((o = t.match(d)) == null ? void 0 : o.length) || 0) + (((e = t.match(N)) == null ? void 0 : e.length) || 0) > 0;
+}
+const p = "number", m = "color", T = "var", O = "var(", a = "${}", R = /var\s*\(\s*--(?:[\w-]+\s*|[\w-]+\s*,(?:\s*[^)(\s]|\s*\((?:[^)(]|\([^)(]*\))*\))+\s*)\)|#[\da-f]{3,8}|(?:rgb|hsl)a?\((?:-?[\d.]+%?[,\s]+){2}-?[\d.]+%?\s*(?:[,/]\s*)?(?:\b\d+(?:\.\d+)?|\.\d+)?%?\)|-?(?:\d+(?:\.\d+)?|\.\d+)/giu;
+function f(t) {
+  const o = t.toString(), e = [], c = {
+    color: [],
+    number: [],
+    var: []
+  }, n = [];
+  let s = 0;
+  const l = o.replace(R, (i) => (u.test(i) ? (c.color.push(s), n.push(m), e.push(u.parse(i))) : i.startsWith(O) ? (c.var.push(s), n.push(T), e.push(i)) : (c.number.push(s), n.push(p), e.push(parseFloat(i))), ++s, a)).split(a);
+  return { values: e, split: l, indexes: c, types: n };
+}
+function h(t) {
+  return f(t).values;
+}
+function g(t) {
+  const { split: o, types: e } = f(t), c = o.length;
+  return (n) => {
+    let s = "";
+    for (let r = 0; r < c; r++)
+      if (s += o[r], n[r] !== void 0) {
+        const l = e[r];
+        l === p ? s += b(n[r]) : l === m ? s += u.transform(n[r]) : s += n[r];
+      }
+    return s;
+  };
+}
+const y = (t) => typeof t == "number" ? 0 : u.test(t) ? u.getAnimatableNone(t) : t;
+function E(t) {
+  const o = h(t);
+  return g(t)(o.map(y));
+}
+const S = {
+  test: x,
+  parse: h,
+  createTransformer: g,
+  getAnimatableNone: E
+};
+export {
+  f as analyseComplexValue,
+  S as complex
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/maps/number.mjs

@@ -0,0 +1,70 @@
+import { int as t } from "../int.mjs";
+import { alpha as n } from "../numbers/index.mjs";
+import { px as i } from "../numbers/units.mjs";
+import { transformValueTypes as o } from "./transform.mjs";
+const g = {
+  // Border props
+  borderWidth: i,
+  borderTopWidth: i,
+  borderRightWidth: i,
+  borderBottomWidth: i,
+  borderLeftWidth: i,
+  borderRadius: i,
+  borderTopLeftRadius: i,
+  borderTopRightRadius: i,
+  borderBottomRightRadius: i,
+  borderBottomLeftRadius: i,
+  // Positioning props
+  width: i,
+  maxWidth: i,
+  height: i,
+  maxHeight: i,
+  top: i,
+  right: i,
+  bottom: i,
+  left: i,
+  inset: i,
+  insetBlock: i,
+  insetBlockStart: i,
+  insetBlockEnd: i,
+  insetInline: i,
+  insetInlineStart: i,
+  insetInlineEnd: i,
+  // Spacing props
+  padding: i,
+  paddingTop: i,
+  paddingRight: i,
+  paddingBottom: i,
+  paddingLeft: i,
+  paddingBlock: i,
+  paddingBlockStart: i,
+  paddingBlockEnd: i,
+  paddingInline: i,
+  paddingInlineStart: i,
+  paddingInlineEnd: i,
+  margin: i,
+  marginTop: i,
+  marginRight: i,
+  marginBottom: i,
+  marginLeft: i,
+  marginBlock: i,
+  marginBlockStart: i,
+  marginBlockEnd: i,
+  marginInline: i,
+  marginInlineStart: i,
+  marginInlineEnd: i,
+  // Typography
+  fontSize: i,
+  // Misc
+  backgroundPositionX: i,
+  backgroundPositionY: i,
+  ...o,
+  zIndex: t,
+  // SVG
+  fillOpacity: n,
+  strokeOpacity: n,
+  numOctaves: t
+};
+export {
+  g as numberValueTypes
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/types/numbers/index.mjs

@@ -0,0 +1,17 @@
+import { clamp as a } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.mjs";
+const r = {
+  test: (t) => typeof t == "number",
+  parse: parseFloat,
+  transform: (t) => t
+}, e = {
+  ...r,
+  transform: (t) => a(0, 1, t)
+}, s = {
+  ...r,
+  default: 1
+};
+export {
+  e as alpha,
+  r as number,
+  s as scale
+};

package/dist/es/node_modules/.pnpm/motion-dom@12.31.2/node_modules/motion-dom/dist/es/value/will-change/add-will-change.mjs

@@ -0,0 +1,14 @@
+import { isWillChangeMotionValue as o } from "./is.mjs";
+import { MotionGlobalConfig as i } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/global-config.mjs";
+function C(a, n) {
+  const l = a.getValue("willChange");
+  if (o(l))
+    return l.add(n);
+  if (!l && i.WillChange) {
+    const e = new i.WillChange("auto");
+    a.addValue("willChange", e), e.add(n);
+  }
+}
+export {
+  C as addValueToWillChange
+};

package/dist/es/node_modules/.pnpm/motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/map.mjs

@@ -0,0 +1,32 @@
+import { invariant as e } from "../../errors.mjs";
+import { noop as c } from "../../noop.mjs";
+import { anticipate as u } from "../anticipate.mjs";
+import { backOut as s, backInOut as m, backIn as p } from "../back.mjs";
+import { circOut as l, circInOut as b, circIn as f } from "../circ.mjs";
+import { cubicBezier as g } from "../cubic-bezier.mjs";
+import { easeOut as I, easeInOut as y, easeIn as O } from "../ease.mjs";
+import { isBezierDefinition as k } from "./is-bezier-definition.mjs";
+const t = {
+  linear: c,
+  easeIn: O,
+  easeInOut: y,
+  easeOut: I,
+  circIn: f,
+  circInOut: b,
+  circOut: l,
+  backIn: p,
+  backInOut: m,
+  backOut: s,
+  anticipate: u
+}, v = (r) => typeof r == "string", L = (r) => {
+  if (k(r)) {
+    e(r.length === 4, "Cubic bezier arrays must contain four numerical values.", "cubic-bezier-length");
+    const [i, n, o, a] = r;
+    return g(i, n, o, a);
+  } else if (v(r))
+    return e(t[r] !== void 0, `Invalid easing type '${r}'`, "invalid-easing-type"), t[r];
+  return r;
+};
+export {
+  L as easingDefinitionToFunction
+};

package/dist/es/node_modules/.pnpm/motion-utils@12.29.2/node_modules/motion-utils/dist/es/errors.mjs

@@ -0,0 +1,15 @@
+import { formatErrorMessage as n } from "./format-error-message.mjs";
+let t = () => {
+}, f = () => {
+};
+var i;
+typeof process < "u" && ((i = process.env) == null ? void 0 : i.NODE_ENV) !== "production" && (t = (e, o, r) => {
+  !e && typeof console < "u" && console.warn(n(o, r));
+}, f = (e, o, r) => {
+  if (!e)
+    throw new Error(n(o, r));
+});
+export {
+  f as invariant,
+  t as warning
+};

package/dist/es/node_modules/.pnpm/motion-utils@12.29.2/node_modules/motion-utils/dist/es/format-error-message.mjs

@@ -0,0 +1,6 @@
+function n(o, t) {
+  return t ? `${o}. For more information and steps for solving, visit https://motion.dev/troubleshooting/${t}` : o;
+}
+export {
+  n as formatErrorMessage
+};

package/dist/es/node_modules/.pnpm/motion-utils@12.29.2/node_modules/motion-utils/dist/es/is-object.mjs

@@ -0,0 +1,6 @@
+function e(t) {
+  return typeof t == "object" && t !== null;
+}
+export {
+  e as isObject
+};

package/dist/es/node_modules/.pnpm/motion-utils@12.29.2/node_modules/motion-utils/dist/es/warn-once.mjs

@@ -0,0 +1,8 @@
+import { formatErrorMessage as a } from "./format-error-message.mjs";
+const n = /* @__PURE__ */ new Set();
+function c(o, r, t) {
+  o || n.has(r) || (console.warn(a(r, t)), n.add(r));
+}
+export {
+  c as warnOnce
+};

package/dist/es/pagination/components/pagination-ellipsis/pagination-ellipsis.mjs

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as c } from "react/jsx-runtime";
+import { usePaginationInnerContext as m } from "../../pagination-inner-context.mjs";
+function f(t) {
+  const { onPageNumberChange: i, allPages: a, current: s, disabled: n } = m(), { jumpPage: o, style: e, className: l, children: r } = t;
+  return /* @__PURE__ */ c("div", { style: e, className: l, onClick: () => {
+    n || i == null || i(Math.min(a, Math.max(1, s + o)));
+  }, "aria-disabled": n, children: r });
+}
+export {
+  f as PaginationEllipsis
+};

package/dist/es/pagination/components/pagination-ellipsis/pagination-end-ellipsis.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { jsx as i, Fragment as r } from "react/jsx-runtime";
+import { PaginationEllipsis as s } from "./pagination-ellipsis.mjs";
+import { usePaginationInnerContext as p } from "../../pagination-inner-context.mjs";
+function u(n) {
+  const { bufferSize: t, shouldShowNextEllipsis: o } = p(), e = t * 2 + 1;
+  return /* @__PURE__ */ i(r, { children: o && /* @__PURE__ */ i(s, { ...n, jumpPage: e }) });
+}
+export {
+  u as PaginationEndEllipsis
+};

package/dist/es/pagination/components/pagination-ellipsis/pagination-start-ellipsis.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { jsx as i, Fragment as e } from "react/jsx-runtime";
+import { PaginationEllipsis as s } from "./pagination-ellipsis.mjs";
+import { usePaginationInnerContext as p } from "../../pagination-inner-context.mjs";
+function u(t) {
+  const { bufferSize: n, shouldShowPrevEllipsis: o } = p(), r = n * 2 + 1;
+  return /* @__PURE__ */ i(e, { children: o && /* @__PURE__ */ i(s, { ...t, jumpPage: -r }) });
+}
+export {
+  u as PaginationStartEllipsis
+};

package/dist/es/pagination/components/pagination-item/pagination-end-item.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { jsx as n, Fragment as i } from "react/jsx-runtime";
+import { PaginationItem as r } from "./pagination-item.mjs";
+import { usePaginationInnerContext as a } from "../../pagination-inner-context.mjs";
+function u(t) {
+  const { allPages: o, shouldShowLast: e } = a();
+  return /* @__PURE__ */ n(i, { children: e && /* @__PURE__ */ n(r, { pageNum: o, ...t }) });
+}
+export {
+  u as PaginationEndItem
+};

package/dist/es/pagination/components/pagination-item/pagination-item.mjs

@@ -0,0 +1,27 @@
+"use client";
+import { jsx as l } from "react/jsx-runtime";
+import { Enter as m } from "../../../utils/keycode.mjs";
+import { usePaginationInnerContext as p } from "../../pagination-inner-context.mjs";
+function C(s) {
+  const { current: a, disabled: t, onPageNumberChange: n } = p(), { className: d, style: f, children: e, pageNum: i } = s, r = a === i, c = (o) => {
+    o.stopPropagation(), t || n == null || n(i);
+  };
+  return /* @__PURE__ */ l(
+    "div",
+    {
+      className: d,
+      style: f,
+      onClick: c,
+      tabIndex: t ? -1 : 0,
+      onKeyDown: (o) => {
+        (o.keyCode || o.which) === m.code && c(o);
+      },
+      "aria-disabled": t,
+      "aria-current": r,
+      children: typeof e == "function" ? e(i, { isActive: r, disabled: t }) : e
+    }
+  );
+}
+export {
+  C as PaginationItem
+};

package/dist/es/pagination/components/pagination-item/pagination-items.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { jsx as n, Fragment as r } from "react/jsx-runtime";
+import { PaginationItem as a } from "./pagination-item.mjs";
+import { usePaginationInnerContext as m } from "../../pagination-inner-context.mjs";
+function g(i) {
+  const { pages: e } = m();
+  return /* @__PURE__ */ n(r, { children: e.map((t) => /* @__PURE__ */ n(a, { pageNum: t, ...i, children: (o) => /* @__PURE__ */ n("span", { children: o }) }, t)) });
+}
+export {
+  g as PaginationItems
+};

package/dist/es/pagination/components/pagination-item/pagination-start-item.mjs

@@ -0,0 +1,11 @@
+"use client";
+import { jsx as t, Fragment as r } from "react/jsx-runtime";
+import { PaginationItem as i } from "./pagination-item.mjs";
+import { usePaginationInnerContext as e } from "../../pagination-inner-context.mjs";
+function u(n) {
+  const { shouldShowFirst: o } = e();
+  return /* @__PURE__ */ t(r, { children: o && /* @__PURE__ */ t(i, { pageNum: 1, ...n }) });
+}
+export {
+  u as PaginationStartItem
+};

package/dist/es/pagination/components/pagination-jumper.mjs

@@ -0,0 +1,33 @@
+"use client";
+import { jsx as d } from "react/jsx-runtime";
+import { usePaginationInnerContext as f } from "../pagination-inner-context.mjs";
+import { useJumperStore as g } from "../store/use-jumper-store.mjs";
+import { InputComponent as c } from "../../input/input.mjs";
+import { isUndefined as h } from "../../utils/is.mjs";
+function J(i) {
+  const { showCurrent: e, className: a, style: s } = i, { current: n, disabled: m, allPages: o, onPageNumberChange: u } = f(), { inputText: t, inputRef: p, handleChange: l, handleJump: r } = g(
+    {
+      allPages: o,
+      current: n,
+      onPageNumberChange: u,
+      showCurrent: e
+    },
+    e ? n : void 0
+  );
+  return /* @__PURE__ */ d(
+    c,
+    {
+      ref: p,
+      value: h(t) ? void 0 : t.toString(),
+      disabled: m || !o,
+      onChange: l,
+      onPressEnter: r,
+      onBlur: r,
+      className: a,
+      style: s
+    }
+  );
+}
+export {
+  J as PaginationJumper
+};

package/dist/es/pagination/components/pagination-option.mjs

@@ -0,0 +1,9 @@
+import { jsx as p } from "react/jsx-runtime";
+import { usePaginationInnerContext as r } from "../pagination-inner-context.mjs";
+function g({ children: n, ...o }) {
+  const { disabled: i, pageSize: t, sizeOptions: e, onPageSizeChange: a } = r();
+  return /* @__PURE__ */ p("div", { ...o, children: typeof n == "function" ? n({ sizeOptions: e, pageSize: t, disabled: i, onPageSizeChange: a }) : n });
+}
+export {
+  g as PaginationOption
+};