@uinstinct/svelte-wheel-picker 0.1.12 → 0.1.14

package/dist/WheelPicker.svelte

@@ -1,4 +1,4 @@
-<script lang="ts">
+<script lang="ts" generics="T extends string | number">
 	import { untrack } from 'svelte';
 	import type { WheelPickerProps } from './types.js';
 	import { WheelPhysics } from './use-wheel-physics.svelte.js';
@@ -25,7 +25,7 @@
 		scrollSensitivity = DEFAULT_SCROLL_SENSITIVITY,
 		infinite = false,
 		cylindrical = false,
-	}: WheelPickerProps = $props();
+	}: WheelPickerProps<T> = $props();
 
 	// D-07: visibleCount must be odd — warn and round up if even
 	const visibleCount = $derived.by(() => {

package/dist/WheelPicker.svelte.d.ts

@@ -1,4 +1,25 @@
 import type { WheelPickerProps } from './types.js';
-declare const WheelPicker: import("svelte").Component<WheelPickerProps<string>, {}, "">;
-type WheelPicker = ReturnType<typeof WheelPicker>;
+declare function $$render<T extends string | number>(): {
+    props: WheelPickerProps<T>;
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T extends string | number> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T extends string | number>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T extends string | number>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const WheelPicker: $$IsomorphicComponent;
+type WheelPicker<T extends string | number> = InstanceType<typeof WheelPicker<T>>;
 export default WheelPicker;

package/dist/use-controllable-state.svelte.js

@@ -1,61 +1,42 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ControllableState_internal, _ControllableState_onChange, _ControllableState_isControlled, _ControllableState_controlledValue;
-var ControllableState = /** @class */ (function () {
-    function ControllableState(opts) {
-        _ControllableState_internal.set(this, $state(undefined));
-        _ControllableState_onChange.set(this, void 0);
-        _ControllableState_isControlled.set(this, void 0);
-        // $state so that reactive consumers (selectedIndex $derived) re-evaluate when prop changes
-        _ControllableState_controlledValue.set(this, $state(undefined));
-        __classPrivateFieldSet(this, _ControllableState_isControlled, typeof opts.onChange === 'function', "f");
-        __classPrivateFieldSet(this, _ControllableState_onChange, opts.onChange, "f");
-        __classPrivateFieldSet(this, _ControllableState_controlledValue, opts.value, "f");
-        if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
-            __classPrivateFieldSet(this, _ControllableState_internal, opts.value, "f");
+class ControllableState {
+    #internal = $state(undefined);
+    #onChange;
+    #isControlled;
+    // $state so that reactive consumers (selectedIndex $derived) re-evaluate when prop changes
+    #controlledValue = $state(undefined);
+    constructor(opts) {
+        this.#isControlled = typeof opts.onChange === 'function';
+        this.#onChange = opts.onChange;
+        this.#controlledValue = opts.value;
+        if (this.#isControlled) {
+            this.#internal = opts.value;
         }
         else {
-            __classPrivateFieldSet(this, _ControllableState_internal, opts.defaultValue, "f");
+            this.#internal = opts.defaultValue;
         }
     }
     /**
      * Update the tracked controlled value when the external `value` prop changes.
      * Must be called from a $effect in the consuming component whenever `value` changes.
      */
-    ControllableState.prototype.updateControlledValue = function (value) {
-        __classPrivateFieldSet(this, _ControllableState_controlledValue, value, "f");
-    };
-    Object.defineProperty(ControllableState.prototype, "current", {
-        get: function () {
-            if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
-                return __classPrivateFieldGet(this, _ControllableState_controlledValue, "f");
-            }
-            return __classPrivateFieldGet(this, _ControllableState_internal, "f");
-        },
-        set: function (next) {
-            var _a;
-            if (__classPrivateFieldGet(this, _ControllableState_isControlled, "f")) {
-                (_a = __classPrivateFieldGet(this, _ControllableState_onChange, "f")) === null || _a === void 0 ? void 0 : _a.call(this, next);
-            }
-            else {
-                __classPrivateFieldSet(this, _ControllableState_internal, next, "f");
-            }
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ControllableState;
-}());
-_ControllableState_internal = new WeakMap(), _ControllableState_onChange = new WeakMap(), _ControllableState_isControlled = new WeakMap(), _ControllableState_controlledValue = new WeakMap();
+    updateControlledValue(value) {
+        this.#controlledValue = value;
+    }
+    get current() {
+        if (this.#isControlled) {
+            return this.#controlledValue;
+        }
+        return this.#internal;
+    }
+    set current(next) {
+        if (this.#isControlled) {
+            this.#onChange?.(next);
+        }
+        else {
+            this.#internal = next;
+        }
+    }
+}
 export function useControllableState(opts) {
     return new ControllableState(opts);
 }

package/dist/use-typeahead-search.svelte.js

@@ -1,77 +1,59 @@
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _TypeaheadSearch_instances, _TypeaheadSearch_buffer, _TypeaheadSearch_lastKey, _TypeaheadSearch_lastTime, _TypeaheadSearch_timer, _TypeaheadSearch_getSearchText, _TypeaheadSearch_findFirst, _TypeaheadSearch_cycleMatch;
-var TypeaheadSearch = /** @class */ (function () {
-    function TypeaheadSearch() {
-        _TypeaheadSearch_instances.add(this);
-        _TypeaheadSearch_buffer.set(this, $state(''));
-        _TypeaheadSearch_lastKey.set(this, $state(''));
-        _TypeaheadSearch_lastTime.set(this, 0);
-        _TypeaheadSearch_timer.set(this, null);
-    }
-    TypeaheadSearch.prototype.search = function (key, options, currentIndex) {
-        var _this = this;
-        var now = Date.now();
-        var withinWindow = now - __classPrivateFieldGet(this, _TypeaheadSearch_lastTime, "f") < 500;
-        var singleChar = key.length === 1;
+class TypeaheadSearch {
+    #buffer = $state('');
+    #lastKey = $state('');
+    #lastTime = 0;
+    #timer = null;
+    search(key, options, currentIndex) {
+        const now = Date.now();
+        const withinWindow = now - this.#lastTime < 500;
+        const singleChar = key.length === 1;
         if (!singleChar)
             return -1;
-        var lowerKey = key.toLowerCase();
-        var isSameKey = withinWindow && lowerKey === __classPrivateFieldGet(this, _TypeaheadSearch_lastKey, "f");
-        __classPrivateFieldSet(this, _TypeaheadSearch_lastKey, lowerKey, "f");
-        __classPrivateFieldSet(this, _TypeaheadSearch_lastTime, now, "f");
+        const lowerKey = key.toLowerCase();
+        const isSameKey = withinWindow && lowerKey === this.#lastKey;
+        this.#lastKey = lowerKey;
+        this.#lastTime = now;
         // Reset timer
-        if (__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"))
-            clearTimeout(__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"));
-        __classPrivateFieldSet(this, _TypeaheadSearch_timer, setTimeout(function () {
-            __classPrivateFieldSet(_this, _TypeaheadSearch_buffer, '', "f");
-            __classPrivateFieldSet(_this, _TypeaheadSearch_lastKey, '', "f");
-        }, 500), "f");
+        if (this.#timer)
+            clearTimeout(this.#timer);
+        this.#timer = setTimeout(() => {
+            this.#buffer = '';
+            this.#lastKey = '';
+        }, 500);
         if (isSameKey) {
             // Same key cycling (D-02): find next match after currentIndex
-            return __classPrivateFieldGet(this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_cycleMatch).call(this, lowerKey, options, currentIndex);
+            return this.#cycleMatch(lowerKey, options, currentIndex);
         }
         else {
             // Accumulate or start fresh
-            __classPrivateFieldSet(this, _TypeaheadSearch_buffer, withinWindow ? __classPrivateFieldGet(this, _TypeaheadSearch_buffer, "f") + lowerKey : lowerKey, "f");
-            return __classPrivateFieldGet(this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_findFirst).call(this, __classPrivateFieldGet(this, _TypeaheadSearch_buffer, "f"), options);
+            this.#buffer = withinWindow ? this.#buffer + lowerKey : lowerKey;
+            return this.#findFirst(this.#buffer, options);
         }
-    };
-    TypeaheadSearch.prototype.destroy = function () {
-        if (__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f")) {
-            clearTimeout(__classPrivateFieldGet(this, _TypeaheadSearch_timer, "f"));
-            __classPrivateFieldSet(this, _TypeaheadSearch_timer, null, "f");
+    }
+    #getSearchText(option) {
+        return (option.textValue ?? option.label).toLowerCase();
+    }
+    #findFirst(prefix, options) {
+        return options.findIndex((o) => !o.disabled && this.#getSearchText(o).startsWith(prefix));
+    }
+    #cycleMatch(key, options, fromIndex) {
+        const prefix = key.toLowerCase();
+        const matches = options
+            .map((o, i) => ({ i, matches: !o.disabled && this.#getSearchText(o).startsWith(prefix) }))
+            .filter((x) => x.matches)
+            .map((x) => x.i);
+        if (matches.length === 0)
+            return -1;
+        const afterCurrent = matches.find((i) => i > fromIndex);
+        return afterCurrent ?? matches[0]; // wrap around
+    }
+    destroy() {
+        if (this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = null;
         }
-    };
-    return TypeaheadSearch;
-}());
-_TypeaheadSearch_buffer = new WeakMap(), _TypeaheadSearch_lastKey = new WeakMap(), _TypeaheadSearch_lastTime = new WeakMap(), _TypeaheadSearch_timer = new WeakMap(), _TypeaheadSearch_instances = new WeakSet(), _TypeaheadSearch_getSearchText = function _TypeaheadSearch_getSearchText(option) {
-    var _a;
-    return ((_a = option.textValue) !== null && _a !== void 0 ? _a : option.label).toLowerCase();
-}, _TypeaheadSearch_findFirst = function _TypeaheadSearch_findFirst(prefix, options) {
-    var _this = this;
-    return options.findIndex(function (o) { return !o.disabled && __classPrivateFieldGet(_this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_getSearchText).call(_this, o).startsWith(prefix); });
-}, _TypeaheadSearch_cycleMatch = function _TypeaheadSearch_cycleMatch(key, options, fromIndex) {
-    var _this = this;
-    var prefix = key.toLowerCase();
-    var matches = options
-        .map(function (o, i) { return ({ i: i, matches: !o.disabled && __classPrivateFieldGet(_this, _TypeaheadSearch_instances, "m", _TypeaheadSearch_getSearchText).call(_this, o).startsWith(prefix) }); })
-        .filter(function (x) { return x.matches; })
-        .map(function (x) { return x.i; });
-    if (matches.length === 0)
-        return -1;
-    var afterCurrent = matches.find(function (i) { return i > fromIndex; });
-    return afterCurrent !== null && afterCurrent !== void 0 ? afterCurrent : matches[0]; // wrap around
-};
+    }
+}
 export function useTypeaheadSearch() {
     return new TypeaheadSearch();
 }

package/dist/use-wheel-physics.svelte.js

@@ -10,67 +10,53 @@
  * - Boundary resistance uses RESISTANCE constant from React v1.2.2 source.
  * - Disabled options are always skipped when computing snap targets.
  */
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _WheelPhysics_instances, _WheelPhysics_itemHeight, _WheelPhysics_visibleCount, _WheelPhysics_dragSensitivity, _WheelPhysics_scrollSensitivity, _WheelPhysics_options, _WheelPhysics_onSnap, _WheelPhysics_infinite, _WheelPhysics_rafId, _WheelPhysics_isDragging, _WheelPhysics_dragStartOffset, _WheelPhysics_dragStartY, _WheelPhysics_yList, _WheelPhysics_lastWheelTime, _WheelPhysics_animating, _WheelPhysics_cancelRaf, _WheelPhysics_indexToOffset, _WheelPhysics_offsetToIndex;
 import { easeOutCubic, indexToOffset, offsetToIndex, clampIndex, wrapIndex, snapToNearestEnabled, calculateVelocity, computeSnapTarget, computeAnimationDuration, RESISTANCE, DEFAULT_DRAG_SENSITIVITY, DEFAULT_SCROLL_SENSITIVITY, DEFAULT_ITEM_HEIGHT, DEFAULT_VISIBLE_COUNT, SNAP_BACK_DECELERATION, } from './wheel-physics-utils.js';
 // Re-export for convenience so consumers only need one import
 export { DEFAULT_DRAG_SENSITIVITY, DEFAULT_SCROLL_SENSITIVITY, DEFAULT_ITEM_HEIGHT, DEFAULT_VISIBLE_COUNT, };
-var WheelPhysics = /** @class */ (function () {
+export class WheelPhysics {
+    // ---------------------------------------------------------------------------
+    // Public reactive state ($state) — the ONLY field bound to the DOM transform
+    // ---------------------------------------------------------------------------
+    offset = $state(0);
+    // ---------------------------------------------------------------------------
+    // Private configuration (set in constructor, may be updated by update())
+    // ---------------------------------------------------------------------------
+    #itemHeight;
+    #visibleCount;
+    #dragSensitivity;
+    #scrollSensitivity;
+    #options;
+    #onSnap;
+    #infinite;
+    // ---------------------------------------------------------------------------
+    // Private non-reactive animation/drag state (NOT $state — Pitfall 2)
+    // ---------------------------------------------------------------------------
+    /** Current RAF handle — null when no animation running */
+    #rafId = null;
+    /** True between pointerdown and pointerup */
+    #isDragging = false;
+    /** The offset value when the current drag began */
+    #dragStartOffset = 0;
+    /** clientY at the start of the current drag (used for direct delta) */
+    #dragStartY = 0;
+    /** Recent pointer positions for velocity calculation: [clientY, timestamp][] */
+    #yList = [];
+    /** Timestamp of the last wheel event (100ms debounce guard) */
+    #lastWheelTime = -Infinity;
+    /** True while a snap or inertia animation is running */
+    #animating = false;
     // ---------------------------------------------------------------------------
     // Constructor
     // ---------------------------------------------------------------------------
-    function WheelPhysics(opts) {
-        var _a, _b, _c, _d, _e;
-        _WheelPhysics_instances.add(this);
-        // ---------------------------------------------------------------------------
-        // Public reactive state ($state) — the ONLY field bound to the DOM transform
-        // ---------------------------------------------------------------------------
-        this.offset = $state(0);
-        // ---------------------------------------------------------------------------
-        // Private configuration (set in constructor, may be updated by update())
-        // ---------------------------------------------------------------------------
-        _WheelPhysics_itemHeight.set(this, void 0);
-        _WheelPhysics_visibleCount.set(this, void 0);
-        _WheelPhysics_dragSensitivity.set(this, void 0);
-        _WheelPhysics_scrollSensitivity.set(this, void 0);
-        _WheelPhysics_options.set(this, void 0);
-        _WheelPhysics_onSnap.set(this, void 0);
-        _WheelPhysics_infinite.set(this, void 0);
-        // ---------------------------------------------------------------------------
-        // Private non-reactive animation/drag state (NOT $state — Pitfall 2)
-        // ---------------------------------------------------------------------------
-        /** Current RAF handle — null when no animation running */
-        _WheelPhysics_rafId.set(this, null);
-        /** True between pointerdown and pointerup */
-        _WheelPhysics_isDragging.set(this, false);
-        /** The offset value when the current drag began */
-        _WheelPhysics_dragStartOffset.set(this, 0);
-        /** clientY at the start of the current drag (used for direct delta) */
-        _WheelPhysics_dragStartY.set(this, 0);
-        /** Recent pointer positions for velocity calculation: [clientY, timestamp][] */
-        _WheelPhysics_yList.set(this, []);
-        /** Timestamp of the last wheel event (100ms debounce guard) */
-        _WheelPhysics_lastWheelTime.set(this, -Infinity);
-        /** True while a snap or inertia animation is running */
-        _WheelPhysics_animating.set(this, false);
-        __classPrivateFieldSet(this, _WheelPhysics_itemHeight, (_a = opts.itemHeight) !== null && _a !== void 0 ? _a : DEFAULT_ITEM_HEIGHT, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_visibleCount, (_b = opts.visibleCount) !== null && _b !== void 0 ? _b : DEFAULT_VISIBLE_COUNT, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_dragSensitivity, (_c = opts.dragSensitivity) !== null && _c !== void 0 ? _c : DEFAULT_DRAG_SENSITIVITY, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_scrollSensitivity, (_d = opts.scrollSensitivity) !== null && _d !== void 0 ? _d : DEFAULT_SCROLL_SENSITIVITY, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_infinite, (_e = opts.infinite) !== null && _e !== void 0 ? _e : false, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_options, opts.options, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_onSnap, opts.onSnap, "f");
-        this.offset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, opts.initialIndex);
+    constructor(opts) {
+        this.#itemHeight = opts.itemHeight ?? DEFAULT_ITEM_HEIGHT;
+        this.#visibleCount = opts.visibleCount ?? DEFAULT_VISIBLE_COUNT;
+        this.#dragSensitivity = opts.dragSensitivity ?? DEFAULT_DRAG_SENSITIVITY;
+        this.#scrollSensitivity = opts.scrollSensitivity ?? DEFAULT_SCROLL_SENSITIVITY;
+        this.#infinite = opts.infinite ?? false;
+        this.#options = opts.options;
+        this.#onSnap = opts.onSnap;
+        this.offset = this.#indexToOffset(opts.initialIndex);
     }
     // ---------------------------------------------------------------------------
     // Configuration update (called when props change in parent component)
@@ -79,47 +65,47 @@ var WheelPhysics = /** @class */ (function () {
      * Update configuration when parent props change.
      * This does NOT re-trigger animation — it takes effect on the next interaction.
      */
-    WheelPhysics.prototype.update = function (opts) {
+    update(opts) {
         if (opts.itemHeight !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_itemHeight, opts.itemHeight, "f");
+            this.#itemHeight = opts.itemHeight;
         if (opts.visibleCount !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_visibleCount, opts.visibleCount, "f");
+            this.#visibleCount = opts.visibleCount;
         if (opts.dragSensitivity !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_dragSensitivity, opts.dragSensitivity, "f");
+            this.#dragSensitivity = opts.dragSensitivity;
         if (opts.scrollSensitivity !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_scrollSensitivity, opts.scrollSensitivity, "f");
+            this.#scrollSensitivity = opts.scrollSensitivity;
         if (opts.infinite !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_infinite, opts.infinite, "f");
+            this.#infinite = opts.infinite;
         if (opts.options !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_options, opts.options, "f");
+            this.#options = opts.options;
         if (opts.onSnap !== undefined)
-            __classPrivateFieldSet(this, _WheelPhysics_onSnap, opts.onSnap, "f");
-    };
+            this.#onSnap = opts.onSnap;
+    }
     // ---------------------------------------------------------------------------
     // Drag handlers (pointer events)
     // ---------------------------------------------------------------------------
     /**
      * Called on pointerdown. Cancels any running animation and begins tracking.
      */
-    WheelPhysics.prototype.startDrag = function (clientY) {
-        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
-        __classPrivateFieldSet(this, _WheelPhysics_isDragging, true, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_animating, false, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, this.offset, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_dragStartY, clientY, "f");
-        __classPrivateFieldSet(this, _WheelPhysics_yList, [[clientY, performance.now()]], "f");
-    };
+    startDrag(clientY) {
+        this.#cancelRaf();
+        this.#isDragging = true;
+        this.#animating = false;
+        this.#dragStartOffset = this.offset;
+        this.#dragStartY = clientY;
+        this.#yList = [[clientY, performance.now()]];
+    }
     /**
      * Called on pointermove. Updates offset applying boundary resistance at ends.
      */
-    WheelPhysics.prototype.moveDrag = function (clientY) {
-        if (!__classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"))
+    moveDrag(clientY) {
+        if (!this.#isDragging)
             return;
-        var delta = clientY - __classPrivateFieldGet(this, _WheelPhysics_dragStartY, "f");
-        var maxOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, 0);
-        var minOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length - 1);
-        var newOffset = __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") + delta;
-        if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
+        const delta = clientY - this.#dragStartY;
+        const maxOffset = this.#indexToOffset(0);
+        const minOffset = this.#indexToOffset(this.#options.length - 1);
+        let newOffset = this.#dragStartOffset + delta;
+        if (this.#infinite) {
             // Infinite mode: normalize offset when the drag exceeds the ghost item bounds.
             // The DOM has 3×N items (before-ghosts + real + after-ghosts), covering rawIndex
             // -N..2N-1. When the pointer is captured outside the container, the user can drag
@@ -128,18 +114,18 @@ var WheelPhysics = /** @class */ (function () {
             //
             // Applying the same shift to #dragStartOffset keeps future delta computations
             // consistent so the drag feels continuous across the normalization boundary.
-            var loopDistance = __classPrivateFieldGet(this, _WheelPhysics_options, "f").length * __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f");
+            const loopDistance = this.#options.length * this.#itemHeight;
             // After-ghost overflow: newOffset went past the last after-ghost (rawIndex >= 2N)
-            var afterGhostEnd = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, 2 * __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
+            const afterGhostEnd = this.#indexToOffset(2 * this.#options.length);
             // Before-ghost overflow: newOffset went past the first before-ghost (rawIndex < -N)
-            var beforeGhostEnd = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, -__classPrivateFieldGet(this, _WheelPhysics_options, "f").length - 1);
+            const beforeGhostEnd = this.#indexToOffset(-this.#options.length - 1);
             while (newOffset < afterGhostEnd) {
                 newOffset += loopDistance;
-                __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") + loopDistance, "f");
+                this.#dragStartOffset += loopDistance;
             }
             while (newOffset > beforeGhostEnd) {
                 newOffset -= loopDistance;
-                __classPrivateFieldSet(this, _WheelPhysics_dragStartOffset, __classPrivateFieldGet(this, _WheelPhysics_dragStartOffset, "f") - loopDistance, "f");
+                this.#dragStartOffset -= loopDistance;
             }
         }
         else {
@@ -153,31 +139,31 @@ var WheelPhysics = /** @class */ (function () {
         }
         this.offset = newOffset;
         // Track last 5 pointer positions for velocity calculation
-        __classPrivateFieldGet(this, _WheelPhysics_yList, "f").push([clientY, performance.now()]);
-        if (__classPrivateFieldGet(this, _WheelPhysics_yList, "f").length > 5) {
-            __classPrivateFieldGet(this, _WheelPhysics_yList, "f").shift();
+        this.#yList.push([clientY, performance.now()]);
+        if (this.#yList.length > 5) {
+            this.#yList.shift();
         }
-    };
+    }
     /**
      * Called on pointerup. Computes velocity and kicks off inertia or direct snap.
      */
-    WheelPhysics.prototype.endDrag = function () {
-        console.log('[endDrag] called, isDragging=', __classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"), 'offset=', this.offset);
-        if (!__classPrivateFieldGet(this, _WheelPhysics_isDragging, "f"))
+    endDrag() {
+        console.log('[endDrag] called, isDragging=', this.#isDragging, 'offset=', this.offset);
+        if (!this.#isDragging)
             return;
-        __classPrivateFieldSet(this, _WheelPhysics_isDragging, false, "f");
-        var velocity = calculateVelocity(__classPrivateFieldGet(this, _WheelPhysics_yList, "f"), __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"));
-        var rawIndex = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
-        var N = __classPrivateFieldGet(this, _WheelPhysics_options, "f").length;
-        var currentIndex = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
+        this.#isDragging = false;
+        const velocity = calculateVelocity(this.#yList, this.#itemHeight);
+        const rawIndex = this.#offsetToIndex(this.offset);
+        const N = this.#options.length;
+        const currentIndex = this.#infinite
             ? wrapIndex(rawIndex, N)
             : clampIndex(rawIndex, N);
-        console.log('[endDrag] velocity=', velocity, 'rawIndex=', rawIndex, 'currentIndex=', currentIndex, 'infinite=', __classPrivateFieldGet(this, _WheelPhysics_infinite, "f"));
+        console.log('[endDrag] velocity=', velocity, 'rawIndex=', rawIndex, 'currentIndex=', currentIndex, 'infinite=', this.#infinite);
         if (Math.abs(velocity) < 0.5) {
             // Slow release — snap directly to nearest enabled option
-            var snapIndex = snapToNearestEnabled(currentIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
+            const snapIndex = snapToNearestEnabled(currentIndex, this.#options);
             console.log('[endDrag] slow path, snapIndex=', snapIndex);
-            if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
+            if (this.#infinite) {
                 // Preserve ghost-section context so the snap animation continues in the
                 // same direction as the drag rather than jumping backward to real-section.
                 // rawIndex is in [-N, 2N-1] (guaranteed by moveDrag normalization).
@@ -185,7 +171,7 @@ var WheelPhysics = /** @class */ (function () {
                 //   before-ghost (rawIndex < 0): animate to snapIndex - N
                 //   after-ghost  (rawIndex >= N): animate to snapIndex + N
                 //   real section (rawIndex in [0, N-1]): animate to snapIndex directly
-                var loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
+                const loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
                 this.animateTo(snapIndex + loopOffset);
             }
             else {
@@ -196,25 +182,25 @@ var WheelPhysics = /** @class */ (function () {
             // Inertia — compute overshoot target
             // Use rawIndex (not currentIndex) so the overshoot accounts for the current
             // ghost-loop position, giving the correct item index after inertia deceleration.
-            var rawTarget = computeSnapTarget(rawIndex, velocity, __classPrivateFieldGet(this, _WheelPhysics_dragSensitivity, "f"));
-            if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
+            const rawTarget = computeSnapTarget(rawIndex, velocity, this.#dragSensitivity);
+            if (this.#infinite) {
                 // snapIndex is the nearest enabled item to the overshoot target (in [0, N-1])
-                var wrapped = wrapIndex(rawTarget, N);
-                var snapIndex = snapToNearestEnabled(wrapped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
+                const wrapped = wrapIndex(rawTarget, N);
+                const snapIndex = snapToNearestEnabled(wrapped, this.#options);
                 // Animate to the ghost-section position of snapIndex matching the current
                 // loop, so the animation moves in the same direction as the drag.
                 // snapIndex is in [0,N-1]; loopOffset is -N, 0, or +N based on current section.
-                var loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
+                const loopOffset = rawIndex < 0 ? -N : rawIndex >= N ? N : 0;
                 console.log('[endDrag] inertia path, rawTarget=', rawTarget, 'wrapped=', wrapped, 'snapIndex=', snapIndex, 'loopOffset=', loopOffset);
                 this.animateTo(snapIndex + loopOffset);
             }
             else {
-                var clamped = clampIndex(rawTarget, N);
-                var snapIndex = snapToNearestEnabled(clamped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
+                const clamped = clampIndex(rawTarget, N);
+                const snapIndex = snapToNearestEnabled(clamped, this.#options);
                 this.animateTo(snapIndex);
             }
         }
-    };
+    }
     // ---------------------------------------------------------------------------
     // Wheel event handler
     // ---------------------------------------------------------------------------
@@ -224,29 +210,29 @@ var WheelPhysics = /** @class */ (function () {
      * deltaY > 0: scroll down → move to next item (higher index)
      * deltaY < 0: scroll up → move to previous item (lower index)
      */
-    WheelPhysics.prototype.handleWheel = function (deltaY) {
-        var now = performance.now();
-        if (now - __classPrivateFieldGet(this, _WheelPhysics_lastWheelTime, "f") < 100)
+    handleWheel(deltaY) {
+        const now = performance.now();
+        if (now - this.#lastWheelTime < 100)
             return;
-        __classPrivateFieldSet(this, _WheelPhysics_lastWheelTime, now, "f");
-        var rawIndex = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
-        var currentIndex = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
-            ? wrapIndex(rawIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length)
-            : clampIndex(rawIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
+        this.#lastWheelTime = now;
+        const rawIndex = this.#offsetToIndex(this.offset);
+        const currentIndex = this.#infinite
+            ? wrapIndex(rawIndex, this.#options.length)
+            : clampIndex(rawIndex, this.#options.length);
         // deltaY > 0 = scroll down = move to next item (increment index)
-        var direction = deltaY > 0 ? 1 : -1;
-        if (__classPrivateFieldGet(this, _WheelPhysics_infinite, "f")) {
-            var next = currentIndex + direction;
-            var wrapped = wrapIndex(next, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
-            var snapIndex = snapToNearestEnabled(wrapped, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
+        const direction = deltaY > 0 ? 1 : -1;
+        if (this.#infinite) {
+            const next = currentIndex + direction;
+            const wrapped = wrapIndex(next, this.#options.length);
+            const snapIndex = snapToNearestEnabled(wrapped, this.#options);
             this.animateTo(snapIndex);
         }
         else {
-            var targetIndex = clampIndex(currentIndex + direction, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
-            var snapIndex = snapToNearestEnabled(targetIndex, __classPrivateFieldGet(this, _WheelPhysics_options, "f"));
+            const targetIndex = clampIndex(currentIndex + direction, this.#options.length);
+            const snapIndex = snapToNearestEnabled(targetIndex, this.#options);
             this.animateTo(snapIndex);
         }
-    };
+    }
     // ---------------------------------------------------------------------------
     // Animation
     // ---------------------------------------------------------------------------
@@ -256,86 +242,96 @@ var WheelPhysics = /** @class */ (function () {
      *
      * Cancels any currently running animation before starting.
      */
-    WheelPhysics.prototype.animateTo = function (targetIndex) {
-        var _this = this;
+    animateTo(targetIndex) {
         console.log('[animateTo] targetIndex=', targetIndex, 'from offset=', this.offset);
-        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
-        __classPrivateFieldSet(this, _WheelPhysics_animating, true, "f");
-        var startOffset = this.offset;
-        var targetOffset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, targetIndex);
-        var distance = Math.abs(targetIndex - __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, startOffset));
-        var durationSec = computeAnimationDuration(distance, __classPrivateFieldGet(this, _WheelPhysics_scrollSensitivity, "f"));
-        var durationMs = durationSec * 1000;
-        var startTime = performance.now();
-        var tick = function (now) {
-            if (!__classPrivateFieldGet(_this, _WheelPhysics_animating, "f"))
+        this.#cancelRaf();
+        this.#animating = true;
+        const startOffset = this.offset;
+        const targetOffset = this.#indexToOffset(targetIndex);
+        const distance = Math.abs(targetIndex - this.#offsetToIndex(startOffset));
+        const durationSec = computeAnimationDuration(distance, this.#scrollSensitivity);
+        const durationMs = durationSec * 1000;
+        const startTime = performance.now();
+        const tick = (now) => {
+            if (!this.#animating)
                 return;
-            var elapsed = now - startTime;
-            var progress = Math.min(elapsed / durationMs, 1);
-            var eased = easeOutCubic(progress);
-            _this.offset = startOffset + (targetOffset - startOffset) * eased;
+            const elapsed = now - startTime;
+            const progress = Math.min(elapsed / durationMs, 1);
+            const eased = easeOutCubic(progress);
+            this.offset = startOffset + (targetOffset - startOffset) * eased;
             if (progress < 1) {
-                __classPrivateFieldSet(_this, _WheelPhysics_rafId, requestAnimationFrame(tick), "f");
+                this.#rafId = requestAnimationFrame(tick);
             }
             else {
                 // Snap to exact target to avoid float accumulation
-                _this.offset = targetOffset;
-                __classPrivateFieldSet(_this, _WheelPhysics_rafId, null, "f");
-                __classPrivateFieldSet(_this, _WheelPhysics_animating, false, "f");
-                __classPrivateFieldGet(_this, _WheelPhysics_onSnap, "f").call(_this, targetIndex);
+                this.offset = targetOffset;
+                this.#rafId = null;
+                this.#animating = false;
+                this.#onSnap(targetIndex);
             }
         };
-        __classPrivateFieldSet(this, _WheelPhysics_rafId, requestAnimationFrame(tick), "f");
-    };
-    Object.defineProperty(WheelPhysics.prototype, "currentIndex", {
-        /**
-         * Returns the option index that the current offset visually corresponds to.
-         * Used to guard against redundant animations when the wheel is already positioned correctly.
-         */
-        get: function () {
-            var raw = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_offsetToIndex).call(this, this.offset);
-            return __classPrivateFieldGet(this, _WheelPhysics_infinite, "f")
-                ? wrapIndex(raw, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length)
-                : clampIndex(raw, __classPrivateFieldGet(this, _WheelPhysics_options, "f").length);
-        },
-        enumerable: false,
-        configurable: true
-    });
+        this.#rafId = requestAnimationFrame(tick);
+    }
+    /**
+     * Returns the option index that the current offset visually corresponds to.
+     * Used to guard against redundant animations when the wheel is already positioned correctly.
+     */
+    get currentIndex() {
+        const raw = this.#offsetToIndex(this.offset);
+        return this.#infinite
+            ? wrapIndex(raw, this.#options.length)
+            : clampIndex(raw, this.#options.length);
+    }
     /**
      * Immediately sets the offset to the position for the given index, no animation.
      * Used for initial render and controlled value updates.
      */
-    WheelPhysics.prototype.jumpTo = function (index) {
-        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
-        this.offset = __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_indexToOffset).call(this, index);
-    };
+    jumpTo(index) {
+        this.#cancelRaf();
+        this.offset = this.#indexToOffset(index);
+    }
     /**
      * Cancels any in-progress animation.
      */
-    WheelPhysics.prototype.cancelAnimation = function () {
-        __classPrivateFieldGet(this, _WheelPhysics_instances, "m", _WheelPhysics_cancelRaf).call(this);
-    };
+    cancelAnimation() {
+        this.#cancelRaf();
+    }
     /**
      * Cleans up RAF on component destroy.
      */
-    WheelPhysics.prototype.destroy = function () {
+    destroy() {
         this.cancelAnimation();
-    };
-    return WheelPhysics;
-}());
-export { WheelPhysics };
-_WheelPhysics_itemHeight = new WeakMap(), _WheelPhysics_visibleCount = new WeakMap(), _WheelPhysics_dragSensitivity = new WeakMap(), _WheelPhysics_scrollSensitivity = new WeakMap(), _WheelPhysics_options = new WeakMap(), _WheelPhysics_onSnap = new WeakMap(), _WheelPhysics_infinite = new WeakMap(), _WheelPhysics_rafId = new WeakMap(), _WheelPhysics_isDragging = new WeakMap(), _WheelPhysics_dragStartOffset = new WeakMap(), _WheelPhysics_dragStartY = new WeakMap(), _WheelPhysics_yList = new WeakMap(), _WheelPhysics_lastWheelTime = new WeakMap(), _WheelPhysics_animating = new WeakMap(), _WheelPhysics_instances = new WeakSet(), _WheelPhysics_cancelRaf = function _WheelPhysics_cancelRaf() {
-    if (__classPrivateFieldGet(this, _WheelPhysics_rafId, "f") !== null) {
-        cancelAnimationFrame(__classPrivateFieldGet(this, _WheelPhysics_rafId, "f"));
-        __classPrivateFieldSet(this, _WheelPhysics_rafId, null, "f");
     }
-    __classPrivateFieldSet(this, _WheelPhysics_animating, false, "f");
-}, _WheelPhysics_indexToOffset = function _WheelPhysics_indexToOffset(index) {
-    var ghostCount = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f") ? __classPrivateFieldGet(this, _WheelPhysics_options, "f").length : 0;
-    return indexToOffset(index + ghostCount, __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"), __classPrivateFieldGet(this, _WheelPhysics_visibleCount, "f"));
-}, _WheelPhysics_offsetToIndex = function _WheelPhysics_offsetToIndex(offset) {
-    var ghostCount = __classPrivateFieldGet(this, _WheelPhysics_infinite, "f") ? __classPrivateFieldGet(this, _WheelPhysics_options, "f").length : 0;
-    return offsetToIndex(offset, __classPrivateFieldGet(this, _WheelPhysics_itemHeight, "f"), __classPrivateFieldGet(this, _WheelPhysics_visibleCount, "f")) - ghostCount;
-};
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    #cancelRaf() {
+        if (this.#rafId !== null) {
+            cancelAnimationFrame(this.#rafId);
+            this.#rafId = null;
+        }
+        this.#animating = false;
+    }
+    /**
+     * Converts an option index to a translateY offset, accounting for before-ghost
+     * rows prepended to the DOM container in infinite mode.
+     *
+     * In infinite mode the container begins with N = options.length ghost rows, so
+     * real item[i] sits at DOM position (N + i) * itemHeight. The offset must be
+     * shifted by -N * itemHeight relative to the non-infinite formula.
+     */
+    #indexToOffset(index) {
+        const ghostCount = this.#infinite ? this.#options.length : 0;
+        return indexToOffset(index + ghostCount, this.#itemHeight, this.#visibleCount);
+    }
+    /**
+     * Converts a translateY offset back to an option index, accounting for the
+     * before-ghost prefix in infinite mode (inverse of #indexToOffset).
+     */
+    #offsetToIndex(offset) {
+        const ghostCount = this.#infinite ? this.#options.length : 0;
+        return offsetToIndex(offset, this.#itemHeight, this.#visibleCount) - ghostCount;
+    }
+}
 // Unused export to prevent unused import warnings
 void SNAP_BACK_DECELERATION;

package/dist/wheel-physics-utils.js

@@ -11,21 +11,21 @@
 // Physics constants (from React source v1.2.2)
 // ---------------------------------------------------------------------------
 /** Boundary resistance factor — how much drag is applied when pulling past the ends. */
-export var RESISTANCE = 0.3;
+export const RESISTANCE = 0.3;
 /** Maximum scroll velocity in items/second. */
-export var MAX_VELOCITY = 30;
+export const MAX_VELOCITY = 30;
 /** Default drag sensitivity (pointer drag delta multiplier for inertia). */
-export var DEFAULT_DRAG_SENSITIVITY = 3;
+export const DEFAULT_DRAG_SENSITIVITY = 3;
 /** Default scroll sensitivity (wheel event multiplier for snap animation duration). */
-export var DEFAULT_SCROLL_SENSITIVITY = 5;
+export const DEFAULT_SCROLL_SENSITIVITY = 5;
 /** Default height in pixels of each option row. */
-export var DEFAULT_ITEM_HEIGHT = 30;
+export const DEFAULT_ITEM_HEIGHT = 30;
 /** Default number of visible option rows. */
-export var DEFAULT_VISIBLE_COUNT = 5;
+export const DEFAULT_VISIBLE_COUNT = 5;
 /** Deceleration constant used in snap-back calculations. */
-export var SNAP_BACK_DECELERATION = 10;
+export const SNAP_BACK_DECELERATION = 10;
 /** Minimum scaleY for cylindrical mode to prevent items collapsing to zero height. */
-export var MIN_CYLINDRICAL_SCALE = 0.1;
+export const MIN_CYLINDRICAL_SCALE = 0.1;
 // ---------------------------------------------------------------------------
 // Pure physics functions
 // ---------------------------------------------------------------------------
@@ -99,18 +99,17 @@ export function wrapIndex(index, optionsLength) {
  * @returns The nearest enabled index
  */
 export function snapToNearestEnabled(targetIndex, options) {
-    var _a, _b, _c;
-    if (!((_a = options[targetIndex]) === null || _a === void 0 ? void 0 : _a.disabled)) {
+    if (!options[targetIndex]?.disabled) {
         return targetIndex;
     }
     // Walk outward from targetIndex to find the nearest enabled option
-    for (var delta = 1; delta < options.length; delta++) {
-        var lower = targetIndex - delta;
-        var upper = targetIndex + delta;
-        if (lower >= 0 && !((_b = options[lower]) === null || _b === void 0 ? void 0 : _b.disabled)) {
+    for (let delta = 1; delta < options.length; delta++) {
+        const lower = targetIndex - delta;
+        const upper = targetIndex + delta;
+        if (lower >= 0 && !options[lower]?.disabled) {
             return lower;
         }
-        if (upper < options.length && !((_c = options[upper]) === null || _c === void 0 ? void 0 : _c.disabled)) {
+        if (upper < options.length && !options[upper]?.disabled) {
             return upper;
         }
     }
@@ -131,13 +130,13 @@ export function calculateVelocity(yList, itemHeight) {
     if (yList.length < 2) {
         return 0;
     }
-    var _a = yList[yList.length - 2], y1 = _a[0], t1 = _a[1];
-    var _b = yList[yList.length - 1], y2 = _b[0], t2 = _b[1];
+    const [y1, t1] = yList[yList.length - 2];
+    const [y2, t2] = yList[yList.length - 1];
     if (t2 === t1) {
         return 0;
     }
-    var velocity = ((y2 - y1) / itemHeight) * (1000 / (t2 - t1));
-    var clamped = Math.max(-MAX_VELOCITY, Math.min(MAX_VELOCITY, velocity));
+    const velocity = ((y2 - y1) / itemHeight) * (1000 / (t2 - t1));
+    const clamped = Math.max(-MAX_VELOCITY, Math.min(MAX_VELOCITY, velocity));
     return clamped;
 }
 /**
@@ -153,11 +152,11 @@ export function calculateVelocity(yList, itemHeight) {
  * @returns The rounded target index after inertia overshoot
  */
 export function computeSnapTarget(currentIndexFromOffset, velocity, dragSensitivity) {
-    var baseDeceleration = dragSensitivity * 10;
-    var overshoot = (0.5 * velocity * velocity) / baseDeceleration;
+    const baseDeceleration = dragSensitivity * 10;
+    const overshoot = (0.5 * velocity * velocity) / baseDeceleration;
     // Velocity sign is inverted relative to index direction:
     // drag down (positive velocity) increases offset → decreases index → overshoot toward lower index.
-    var rawTarget = currentIndexFromOffset - Math.sign(velocity) * overshoot;
+    const rawTarget = currentIndexFromOffset - Math.sign(velocity) * overshoot;
     return Math.round(rawTarget);
 }
 /**
@@ -171,7 +170,7 @@ export function computeSnapTarget(currentIndexFromOffset, velocity, dragSensitiv
  * @returns Animation duration in seconds
  */
 export function computeAnimationDuration(distance, scrollSensitivity) {
-    var raw = Math.sqrt(Math.abs(distance) / scrollSensitivity);
+    const raw = Math.sqrt(Math.abs(distance) / scrollSensitivity);
     return Math.max(0.1, Math.min(0.6, raw));
 }
 /**
@@ -193,7 +192,7 @@ export function computeAnimationDuration(distance, scrollSensitivity) {
  * @returns scaleY in range [MIN_CYLINDRICAL_SCALE, 1.0]
  */
 export function cylindricalScaleY(slotIndex, offset, itemHeight, visibleCount) {
-    var dist = slotIndex + offset / itemHeight - Math.floor(visibleCount / 2);
-    var angle = (dist * Math.PI) / visibleCount;
+    const dist = slotIndex + offset / itemHeight - Math.floor(visibleCount / 2);
+    const angle = (dist * Math.PI) / visibleCount;
     return Math.max(MIN_CYLINDRICAL_SCALE, Math.cos(angle));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uinstinct/svelte-wheel-picker",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "type": "module",
   "description": "iOS-style wheel picker for Svelte 5 with inertia scrolling, infinite loop, and keyboard navigation",
   "license": "MIT",