@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta

package/dist/es/components/internal/Calendar/calendar/timeframe/frames/TimeFrame.js

@@ -1,316 +1,496 @@
-var Bt = Object.defineProperty;
-var St = (m, s, i) => s in m ? Bt(m, s, { enumerable: !0, configurable: !0, writable: !0, value: i }) : m[s] = i;
-var Q = (m, s, i) => (St(m, typeof s != "symbol" ? s + "" : s, i), i), ht = (m, s, i) => {
-  if (!s.has(m))
-    throw TypeError("Cannot " + i);
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
-var t = (m, s, i) => (ht(m, s, "read from private field"), i ? i.call(m) : s.get(m)), r = (m, s, i) => {
-  if (s.has(m))
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
-  s instanceof WeakSet ? s.add(m) : s.set(m, i);
-}, e = (m, s, i, h) => (ht(m, s, "write to private field"), h ? h.call(m, i) : s.set(m, i), i);
-var M = (m, s, i, h) => ({
-  set _(o) {
-    e(m, s, o, i);
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
   },
   get _() {
-    return t(m, s, h);
-  }
-}), n = (m, s, i) => (ht(m, s, "access private method"), i);
-import { resolveTimeFrameBlockSize as Ct, downsizeTimeFrame as ct } from "../common/utils.js";
-import { UNBOUNDED_SLICE as lt } from "../../timeslice/index.js";
-import { computeTimestampOffset as Et } from "../../utils.js";
-import { FIRST_WEEK_DAYS as Rt, SHIFT_FRAME as nt, SHIFT_PERIOD as yt, SHIFT_BLOCK as Dt, CURSOR_NEXT_BLOCK as At, CURSOR_PREV_BLOCK as _t, CURSOR_LINE_END as wt, CURSOR_LINE_START as xt, CURSOR_BLOCK_END as Ut, CURSOR_BLOCK_START as vt, CURSOR_DOWNWARD as Lt, CURSOR_UPWARD as Nt, CURSOR_FORWARD as bt, CURSOR_BACKWARD as Wt, SELECTION_TO as at, SELECTION_FROM as Z, SELECTION_COLLAPSE as Mt, SELECTION_NEAREST as ut, SELECTION_FARTHEST as dt } from "../../constants.js";
-import Ht from "../common/flags.js";
-import tt from "../../shared/indexed/index.js";
-import { isFunction as zt, isInfinite as mt, clamp as ot, mid as Kt, isBitSafeInteger as gt, enumerable as k, struct as $t, mod as Vt } from "../../../../../../utils/common/index.js";
-import Xt from "../../../clock/today.js";
-var U, g, z, K, $, V, T, F, A, v, L, N, _, B, X, l, c, u, E, b, R, Y, j, y, S, q, G, st, it, et, Ot, C, D, rt, Ft, p, O, w, H, J, ft;
-const x = class x {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _DEFAULT_LOCALE, _cursorBlockIndex, _cursorBlockStartIndex, _cursorBlockEndIndex, _cursorStartIndex, _cursorEndIndex, _cursorIndex, _cursorOffset, _cursorTimestamp, _dynamicBlockHeight, _effect, _firstWeekDay, _frameBlocksCached, _locale, _maxFrameSize, _selectionStartTimestamp, _selectionEndTimestamp, _size, _timeslice, _today, _unwatchCurrentDay, _fromTimestamp, _toTimestamp, _fromBlockOffsetFromOrigin, _toBlockOffsetFromOrigin, _numberOfBlocks, _numberOfUnits, _daysOfWeek, _frameBlocks, _getClampedFrameOffset, getClampedFrameOffset_fn, _getContainedTimestamp, getContainedTimestamp_fn, _getFrameBlockAtIndex, getFrameBlockAtIndex_fn, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn, _shiftOrigin, shiftOrigin_fn, _shiftOriginIfNecessary, shiftOriginIfNecessary_fn;
+import { resolveTimeFrameBlockSize, downsizeTimeFrame } from "../common/utils.js";
+import { UNBOUNDED_SLICE } from "../../timeslice/index.js";
+import { computeTimestampOffset } from "../../utils.js";
+import { FIRST_WEEK_DAYS, SHIFT_FRAME, SHIFT_PERIOD, SHIFT_BLOCK, CURSOR_NEXT_BLOCK, CURSOR_PREV_BLOCK, CURSOR_LINE_END, CURSOR_LINE_START, CURSOR_BLOCK_END, CURSOR_BLOCK_START, CURSOR_DOWNWARD, CURSOR_UPWARD, CURSOR_FORWARD, CURSOR_BACKWARD, SELECTION_TO, SELECTION_FROM, SELECTION_COLLAPSE, SELECTION_NEAREST, SELECTION_FARTHEST } from "../../constants.js";
+import { c as createFlagsRecord } from "../../../../../../../flags-41c36e13.mjs";
+import indexed from "../../shared/indexed/index.js";
+import { isFunction, isInfinite, clamp, mid, isBitSafeInteger, enumerable, struct, mod } from "../../../../../../utils/common/index.js";
+import "../../../clock/clock.js";
+import today from "../../../clock/today.js";
+const _TimeFrame = class _TimeFrame {
   constructor() {
-    r(this, et);
-    r(this, C);
-    r(this, rt);
-    r(this, p);
-    r(this, w);
-    r(this, J);
-    r(this, g, 0);
-    r(this, z, void 0);
-    r(this, K, void 0);
-    r(this, $, -1);
-    r(this, V, -1);
-    r(this, T, void 0);
-    r(this, F, void 0);
-    r(this, A, void 0);
-    r(this, v, !1);
-    r(this, L, void 0);
-    r(this, N, 0);
-    r(this, _, []);
-    r(this, B, t(x, U));
-    r(this, X, 12);
-    r(this, l, void 0);
-    r(this, c, void 0);
-    r(this, u, 1);
-    r(this, E, void 0);
-    r(this, b, Xt());
-    r(this, R, void 0);
-    r(this, Y, -1 / 0);
-    r(this, j, 1 / 0);
-    r(this, y, -1 / 0);
-    r(this, S, 1 / 0);
-    r(this, q, 1 / 0);
-    r(this, G, 0);
-    Q(this, "daysInWeek", 0);
-    Q(this, "origin");
-    Q(this, "originTimestamp");
-    r(this, st, tt(() => this.daysInWeek, this.getDayOfWeekAtIndex.bind(this)));
-    r(this, it, tt(() => t(this, u), n(this, rt, Ft).bind(this)));
+    __privateAdd(this, _getClampedFrameOffset);
+    __privateAdd(this, _getContainedTimestamp);
+    __privateAdd(this, _getFrameBlockAtIndex);
+    __privateAdd(this, _shiftFrameCursorByOffset);
+    __privateAdd(this, _shiftOrigin);
+    __privateAdd(this, _shiftOriginIfNecessary);
+    __privateAdd(this, _cursorBlockIndex, void 0);
+    __privateAdd(this, _cursorBlockStartIndex, void 0);
+    __privateAdd(this, _cursorBlockEndIndex, void 0);
+    __privateAdd(this, _cursorStartIndex, void 0);
+    __privateAdd(this, _cursorEndIndex, void 0);
+    __privateAdd(this, _cursorIndex, void 0);
+    __privateAdd(this, _cursorOffset, void 0);
+    __privateAdd(this, _cursorTimestamp, void 0);
+    __privateAdd(this, _dynamicBlockHeight, void 0);
+    __privateAdd(this, _effect, void 0);
+    __privateAdd(this, _firstWeekDay, void 0);
+    __privateAdd(this, _frameBlocksCached, void 0);
+    __privateAdd(this, _locale, void 0);
+    __privateAdd(this, _maxFrameSize, void 0);
+    __privateAdd(this, _selectionStartTimestamp, void 0);
+    __privateAdd(this, _selectionEndTimestamp, void 0);
+    __privateAdd(this, _size, void 0);
+    __privateAdd(this, _timeslice, void 0);
+    __privateAdd(this, _today, void 0);
+    __privateAdd(this, _unwatchCurrentDay, void 0);
+    __privateAdd(this, _fromTimestamp, void 0);
+    __privateAdd(this, _toTimestamp, void 0);
+    __privateAdd(this, _fromBlockOffsetFromOrigin, void 0);
+    __privateAdd(this, _toBlockOffsetFromOrigin, void 0);
+    __privateAdd(this, _numberOfBlocks, void 0);
+    __privateAdd(this, _numberOfUnits, void 0);
+    __privateAdd(this, _daysOfWeek, void 0);
+    __privateAdd(this, _frameBlocks, void 0);
+    __privateSet(this, _cursorBlockIndex, 0);
+    __privateSet(this, _cursorStartIndex, -1);
+    __privateSet(this, _cursorEndIndex, -1);
+    __privateSet(this, _dynamicBlockHeight, false);
+    __privateSet(this, _firstWeekDay, 0);
+    __privateSet(this, _frameBlocksCached, []);
+    __privateSet(this, _locale, __privateGet(_TimeFrame, _DEFAULT_LOCALE));
+    __privateSet(this, _maxFrameSize, 12);
+    __privateSet(this, _size, 1);
+    __privateSet(this, _today, today());
+    __privateSet(this, _fromTimestamp, -Infinity);
+    __privateSet(this, _toTimestamp, Infinity);
+    __privateSet(this, _fromBlockOffsetFromOrigin, -Infinity);
+    __privateSet(this, _toBlockOffsetFromOrigin, Infinity);
+    __privateSet(this, _numberOfBlocks, Infinity);
+    __privateSet(this, _numberOfUnits, 0);
+    this.daysInWeek = 0;
+    __privateSet(this, _daysOfWeek, indexed(() => this.daysInWeek, this.getDayOfWeekAtIndex.bind(this)));
+    __privateSet(this, _frameBlocks, indexed(() => __privateGet(this, _size), __privateMethod(this, _getFrameBlockAtIndex, getFrameBlockAtIndex_fn).bind(this)));
   }
   get fromTimestamp() {
-    return t(this, Y);
+    return __privateGet(this, _fromTimestamp);
   }
   get toTimestamp() {
-    return t(this, j);
+    return __privateGet(this, _toTimestamp);
   }
   get numberOfBlocks() {
-    return t(this, q);
+    return __privateGet(this, _numberOfBlocks);
   }
   get blankSelection() {
-    return t(this, l) === t(this, c) && t(this, c) === void 0;
+    return __privateGet(this, _selectionStartTimestamp) === __privateGet(this, _selectionEndTimestamp) && __privateGet(this, _selectionEndTimestamp) === void 0;
   }
   get cursor() {
-    return t(this, T) ?? -1;
+    return __privateGet(this, _cursorIndex) ?? -1;
   }
   get daysOfWeek() {
-    return t(this, st);
+    return __privateGet(this, _daysOfWeek);
   }
   get dynamicBlockHeight() {
-    return t(this, v);
+    return __privateGet(this, _dynamicBlockHeight);
   }
-  set dynamicBlockHeight(s) {
-    s == null ? e(this, v, !!s) : s === !!s && e(this, v, s);
+  set dynamicBlockHeight(bool) {
+    if (bool == void 0)
+      __privateSet(this, _dynamicBlockHeight, !!bool);
+    else if (bool === Boolean(bool))
+      __privateSet(this, _dynamicBlockHeight, bool);
   }
-  set effect(s) {
-    s == null ? e(this, L, void 0) : zt(s) && e(this, L, s);
+  set effect(effect) {
+    if (effect == void 0)
+      __privateSet(this, _effect, void 0);
+    else if (isFunction(effect))
+      __privateSet(this, _effect, effect);
   }
   get firstWeekDay() {
-    return t(this, N);
+    return __privateGet(this, _firstWeekDay);
   }
-  set firstWeekDay(s) {
-    if (s != null) {
-      if (!Rt.includes(s) || t(this, N) === e(this, N, s))
+  set firstWeekDay(day) {
+    if (day != void 0) {
+      if (!FIRST_WEEK_DAYS.includes(day))
+        return;
+      if (__privateGet(this, _firstWeekDay) === __privateSet(this, _firstWeekDay, day))
         return;
     } else
       this.firstWeekDay = 0;
   }
   get frameBlocks() {
-    return t(this, it);
+    return __privateGet(this, _frameBlocks);
   }
   get isAtEnd() {
-    return !mt(t(this, S)) && t(this, S) === t(this, u) - 1;
+    return !isInfinite(__privateGet(this, _toBlockOffsetFromOrigin)) && __privateGet(this, _toBlockOffsetFromOrigin) === __privateGet(this, _size) - 1;
   }
   get isAtStart() {
-    return !mt(t(this, y)) && t(this, y) === 0;
+    return !isInfinite(__privateGet(this, _fromBlockOffsetFromOrigin)) && __privateGet(this, _fromBlockOffsetFromOrigin) === 0;
   }
   get locale() {
-    return t(this, B);
+    return __privateGet(this, _locale);
   }
-  set locale(s) {
-    const i = t(this, B);
-    if (s == null)
-      e(this, B, t(x, U));
-    else if (typeof Intl < "u")
+  set locale(locale) {
+    const currentLocale = __privateGet(this, _locale);
+    if (locale == void 0) {
+      __privateSet(this, _locale, __privateGet(_TimeFrame, _DEFAULT_LOCALE));
+    } else if (typeof Intl !== "undefined") {
       try {
-        e(this, B, new Intl.Locale(s).toString());
+        __privateSet(this, _locale, new Intl.Locale(locale).toString());
       } catch {
-        e(this, B, t(x, U));
+        __privateSet(this, _locale, __privateGet(_TimeFrame, _DEFAULT_LOCALE));
       }
-    t(this, B) !== i && this.refreshFrame(!0);
+    }
+    if (__privateGet(this, _locale) !== currentLocale)
+      this.refreshFrame(true);
   }
   get selectionStart() {
-    return t(this, l);
+    return __privateGet(this, _selectionStartTimestamp);
   }
   get selectionEnd() {
-    return t(this, c);
+    return __privateGet(this, _selectionEndTimestamp);
   }
   get size() {
-    return t(this, u);
+    return __privateGet(this, _size);
   }
-  set size(s) {
-    const i = Math.min(s != null && Ct(s) || 1, t(this, X));
-    t(this, u) !== e(this, u, i) && (n(this, J, ft).call(this), this.refreshFrame());
+  set size(size) {
+    const nextFrameSize = Math.min(size != void 0 && resolveTimeFrameBlockSize(size) || 1, __privateGet(this, _maxFrameSize));
+    if (__privateGet(this, _size) === __privateSet(this, _size, nextFrameSize))
+      return;
+    __privateMethod(this, _shiftOriginIfNecessary, shiftOriginIfNecessary_fn).call(this);
+    this.refreshFrame();
   }
   get timeslice() {
-    return t(this, E);
+    return __privateGet(this, _timeslice);
   }
-  set timeslice(s) {
-    if (s === t(this, E) || s == null && t(this, E) === lt)
+  set timeslice(timeslice) {
+    if (timeslice === __privateGet(this, _timeslice) || timeslice == void 0 && __privateGet(this, _timeslice) === UNBOUNDED_SLICE)
       return;
-    const { from: i, to: h, span: o, offsets: a } = s;
-    e(this, E, s), e(this, Y, i - a.from), e(this, j, h - a.to), e(this, q, o);
-    const d = t(this, l) === void 0 ? t(this, l) : Math.max(t(this, l), i), f = t(this, c) === void 0 ? t(this, c) : Math.min(t(this, c), h);
-    d === t(this, l) || f === t(this, c) ? (e(this, l, d), e(this, c, f)) : e(this, l, e(this, c, void 0)), this.reslice(), e(this, X, ct(12, this.numberOfBlocks)), e(this, u, ct(t(this, u), this.numberOfBlocks)), this.shiftFrameToTimestamp(t(this, A));
-  }
-  set trackCurrentDay(s) {
-    s === !!s ? s && !t(this, R) ? e(this, R, t(this, b).watch(this.refreshFrame.bind(this, !0))) : !s && t(this, R) && (t(this, R).call(this), e(this, R, void 0)) : s == null && (this.trackCurrentDay = !1);
+    const { from, to, span, offsets } = timeslice;
+    __privateSet(this, _timeslice, timeslice);
+    __privateSet(this, _fromTimestamp, from - offsets.from);
+    __privateSet(this, _toTimestamp, to - offsets.to);
+    __privateSet(this, _numberOfBlocks, span);
+    const selectionStartTimestamp = __privateGet(this, _selectionStartTimestamp) === void 0 ? __privateGet(this, _selectionStartTimestamp) : Math.max(__privateGet(this, _selectionStartTimestamp), from);
+    const selectionEndTimestamp = __privateGet(this, _selectionEndTimestamp) === void 0 ? __privateGet(this, _selectionEndTimestamp) : Math.min(__privateGet(this, _selectionEndTimestamp), to);
+    if (selectionStartTimestamp === __privateGet(this, _selectionStartTimestamp) || selectionEndTimestamp === __privateGet(this, _selectionEndTimestamp)) {
+      __privateSet(this, _selectionStartTimestamp, selectionStartTimestamp);
+      __privateSet(this, _selectionEndTimestamp, selectionEndTimestamp);
+    } else
+      __privateSet(this, _selectionStartTimestamp, __privateSet(this, _selectionEndTimestamp, void 0));
+    this.reslice();
+    __privateSet(this, _maxFrameSize, downsizeTimeFrame(12, this.numberOfBlocks));
+    __privateSet(this, _size, downsizeTimeFrame(__privateGet(this, _size), this.numberOfBlocks));
+    this.shiftFrameToTimestamp(__privateGet(this, _cursorTimestamp));
+  }
+  set trackCurrentDay(bool) {
+    if (bool === Boolean(bool)) {
+      if (bool && !__privateGet(this, _unwatchCurrentDay)) {
+        __privateSet(this, _unwatchCurrentDay, __privateGet(this, _today).watch(this.refreshFrame.bind(this, true)));
+      } else if (!bool && __privateGet(this, _unwatchCurrentDay)) {
+        __privateGet(this, _unwatchCurrentDay).call(this);
+        __privateSet(this, _unwatchCurrentDay, void 0);
+      }
+    } else if (bool == void 0)
+      this.trackCurrentDay = false;
   }
   get units() {
-    return t(this, G);
+    return __privateGet(this, _numberOfUnits);
   }
   initialize() {
-    this.withCurrentDayTimestamp(t(this, b).timestamp), this.timeslice = lt;
-  }
-  refreshFrame(s = !1) {
-    var i;
-    if (t(this, _).length = 0, !(t(this, F) === void 0 || s)) {
-      const h = this.getFrameBlockAtIndex(t(this, g)), { from: o, to: a } = h.inner, [d] = n(this, C, D).call(this, this.getTimestampAtIndex(o + t(this, F)), !1);
-      e(this, F, this.getUnitsOffsetForTimestamp(this.getTimestampAtIndex(o), d));
-      const f = o + t(this, F), I = ot(o, f, a);
-      if (I > f)
-        return e(this, F, this.getUnitsForFrameBlockAtIndex(--M(this, g)._) + f - I), t(this, g) >= 0 ? this.refreshFrame() : (e(this, g, t(this, u) - 1), this.shiftFrameByOffset(-1, nt));
-      if (I < f)
-        return e(this, F, f - I - 1), ++M(this, g)._ < t(this, u) ? this.refreshFrame() : (e(this, g, 0), this.shiftFrameByOffset(1, nt));
-      e(this, z, o), e(this, K, a), e(this, A, n(this, C, D).call(this, this.getTimestampAtIndex(f), !1)[0]), e(this, F, this.getCursorBlockOriginTimestampOffset(t(this, A))), e(this, T, o + t(this, F));
-      const P = t(this, g) > 0 ? this.getFrameBlockAtIndex(0) : h, W = t(this, g) < t(this, u) - 1 ? this.getFrameBlockAtIndex(t(this, u) - 1) : h;
-      e(this, $, P.inner.from), e(this, V, W.inner.to), e(this, G, W.outer.to);
+    this.withCurrentDayTimestamp(__privateGet(this, _today).timestamp);
+    this.timeslice = UNBOUNDED_SLICE;
+  }
+  refreshFrame(skipCursorRefresh = false) {
+    var _a;
+    __privateGet(this, _frameBlocksCached).length = 0;
+    if (!(__privateGet(this, _cursorOffset) === void 0 || skipCursorRefresh)) {
+      const cursorBlock = this.getFrameBlockAtIndex(__privateGet(this, _cursorBlockIndex));
+      const { from: startIndex, to: endIndex } = cursorBlock.inner;
+      const [nextCursorTimestamp] = __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, this.getTimestampAtIndex(startIndex + __privateGet(this, _cursorOffset)), false);
+      __privateSet(this, _cursorOffset, this.getUnitsOffsetForTimestamp(this.getTimestampAtIndex(startIndex), nextCursorTimestamp));
+      const nextCursorOffset = startIndex + __privateGet(this, _cursorOffset);
+      const clampedNextCursorOffset = clamp(startIndex, nextCursorOffset, endIndex);
+      if (clampedNextCursorOffset > nextCursorOffset) {
+        __privateSet(this, _cursorOffset, this.getUnitsForFrameBlockAtIndex(--__privateWrapper(this, _cursorBlockIndex)._) + nextCursorOffset - clampedNextCursorOffset);
+        if (__privateGet(this, _cursorBlockIndex) >= 0)
+          return this.refreshFrame();
+        __privateSet(this, _cursorBlockIndex, __privateGet(this, _size) - 1);
+        return this.shiftFrameByOffset(-1, SHIFT_FRAME);
+      }
+      if (clampedNextCursorOffset < nextCursorOffset) {
+        __privateSet(this, _cursorOffset, nextCursorOffset - clampedNextCursorOffset - 1);
+        if (++__privateWrapper(this, _cursorBlockIndex)._ < __privateGet(this, _size))
+          return this.refreshFrame();
+        __privateSet(this, _cursorBlockIndex, 0);
+        return this.shiftFrameByOffset(1, SHIFT_FRAME);
+      }
+      __privateSet(this, _cursorBlockStartIndex, startIndex);
+      __privateSet(this, _cursorBlockEndIndex, endIndex);
+      __privateSet(this, _cursorTimestamp, __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, this.getTimestampAtIndex(nextCursorOffset), false)[0]);
+      __privateSet(this, _cursorOffset, this.getCursorBlockOriginTimestampOffset(__privateGet(this, _cursorTimestamp)));
+      __privateSet(this, _cursorIndex, startIndex + __privateGet(this, _cursorOffset));
+      const firstBlock = __privateGet(this, _cursorBlockIndex) > 0 ? this.getFrameBlockAtIndex(0) : cursorBlock;
+      const lastBlock = __privateGet(this, _cursorBlockIndex) < __privateGet(this, _size) - 1 ? this.getFrameBlockAtIndex(__privateGet(this, _size) - 1) : cursorBlock;
+      __privateSet(this, _cursorStartIndex, firstBlock.inner.from);
+      __privateSet(this, _cursorEndIndex, lastBlock.inner.to);
+      __privateSet(this, _numberOfUnits, lastBlock.outer.to);
     }
-    this.withCurrentDayTimestamp(t(this, b).timestamp), (i = t(this, L)) == null || i.call(this);
-  }
-  shiftFrameByOffset(s, i) {
-    if (s && gt(s))
-      switch (i) {
-        case Dt:
-          return n(this, w, H).call(this, s);
-        case yt:
-          return n(this, w, H).call(this, s * 12);
-        case nt:
+    this.withCurrentDayTimestamp(__privateGet(this, _today).timestamp);
+    (_a = __privateGet(this, _effect)) == null ? void 0 : _a.call(this);
+  }
+  shiftFrameByOffset(offset, offsetType) {
+    if (offset && isBitSafeInteger(offset)) {
+      switch (offsetType) {
+        case SHIFT_BLOCK:
+          return __privateMethod(this, _shiftOrigin, shiftOrigin_fn).call(this, offset);
+        case SHIFT_PERIOD:
+          return __privateMethod(this, _shiftOrigin, shiftOrigin_fn).call(this, offset * 12);
+        case SHIFT_FRAME:
         default:
-          return n(this, w, H).call(this, s * t(this, u));
+          return __privateMethod(this, _shiftOrigin, shiftOrigin_fn).call(this, offset * __privateGet(this, _size));
       }
+    }
   }
-  shiftFrameCursor(s) {
-    switch (s) {
-      case Wt:
-        return n(this, p, O).call(this, -1);
-      case bt:
-        return n(this, p, O).call(this, 1);
-      case Nt:
-        return n(this, p, O).call(this, -this.rowspan);
-      case Lt:
-        return n(this, p, O).call(this, this.rowspan);
-      case vt:
-        return n(this, p, O).call(this, t(this, z) - t(this, T));
-      case Ut:
-        return n(this, p, O).call(this, t(this, K) - t(this, T));
-      case xt:
-        return n(this, p, O).call(this, -(t(this, T) % this.rowspan));
-      case wt:
-        return n(this, p, O).call(this, this.rowspan - (t(this, T) % this.rowspan + 1));
-      case _t:
-        return n(this, p, O).call(this, -this.getUnitsForFrameBlockAtIndex((t(this, g) ?? 0) - 1));
-      case At:
-        return n(this, p, O).call(this, this.getUnitsForFrameBlockAtIndex(t(this, g) ?? 0));
+  shiftFrameCursor(nextCursorPosition) {
+    switch (nextCursorPosition) {
+      case CURSOR_BACKWARD:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, -1);
+      case CURSOR_FORWARD:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, 1);
+      case CURSOR_UPWARD:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, -this.rowspan);
+      case CURSOR_DOWNWARD:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, this.rowspan);
+      case CURSOR_BLOCK_START:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, __privateGet(this, _cursorBlockStartIndex) - __privateGet(this, _cursorIndex));
+      case CURSOR_BLOCK_END:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, __privateGet(this, _cursorBlockEndIndex) - __privateGet(this, _cursorIndex));
+      case CURSOR_LINE_START:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, -(__privateGet(this, _cursorIndex) % this.rowspan));
+      case CURSOR_LINE_END:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, this.rowspan - (__privateGet(this, _cursorIndex) % this.rowspan + 1));
+      case CURSOR_PREV_BLOCK:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, -this.getUnitsForFrameBlockAtIndex((__privateGet(this, _cursorBlockIndex) ?? 0) - 1));
+      case CURSOR_NEXT_BLOCK:
+        return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, this.getUnitsForFrameBlockAtIndex(__privateGet(this, _cursorBlockIndex) ?? 0));
+    }
+    if (nextCursorPosition < 0)
+      return;
+    if (nextCursorPosition >= __privateGet(this, _cursorStartIndex) && nextCursorPosition <= __privateGet(this, _cursorEndIndex)) {
+      return __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, nextCursorPosition - __privateGet(this, _cursorIndex));
     }
-    if (!(s < 0) && s >= t(this, $) && s <= t(this, V))
-      return n(this, p, O).call(this, s - t(this, T));
   }
-  shiftFrameToTimestamp(s) {
-    const i = n(this, C, D).call(this, s, !1)[0];
-    e(this, F, this.getCursorBlockOriginTimestampOffset(e(this, A, this.originTimestamp = i))), this.reoriginate(), [M(this, y)._, M(this, S)._] = this.getEdgeBlockOffsetsFromOrigin(), n(this, J, ft).call(this), this.refreshFrame(), n(this, p, O).call(this, this.getUnitsOffsetForTimestamp(this.getTimestampAtIndex(t(this, T)), i));
+  shiftFrameToTimestamp(timestamp) {
+    const containedTimestamp = __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, timestamp, false)[0];
+    __privateSet(this, _cursorOffset, this.getCursorBlockOriginTimestampOffset(__privateSet(this, _cursorTimestamp, this.originTimestamp = containedTimestamp)));
+    this.reoriginate();
+    [__privateWrapper(this, _fromBlockOffsetFromOrigin)._, __privateWrapper(this, _toBlockOffsetFromOrigin)._] = this.getEdgeBlockOffsetsFromOrigin();
+    __privateMethod(this, _shiftOriginIfNecessary, shiftOriginIfNecessary_fn).call(this);
+    this.refreshFrame();
+    __privateMethod(this, _shiftFrameCursorByOffset, shiftFrameCursorByOffset_fn).call(this, this.getUnitsOffsetForTimestamp(this.getTimestampAtIndex(__privateGet(this, _cursorIndex)), containedTimestamp));
   }
   clearSelection() {
-    this.blankSelection || (e(this, l, e(this, c, void 0)), this.refreshFrame(!0));
-  }
-  getCursorOrderForTimeRelativeToSelectionEdge(s, i = Z) {
-    let h, o = !1;
-    switch (i) {
-      case Z:
-        h = t(this, l);
+    if (this.blankSelection)
+      return;
+    __privateSet(this, _selectionStartTimestamp, __privateSet(this, _selectionEndTimestamp, void 0));
+    this.refreshFrame(true);
+  }
+  getCursorOrderForTimeRelativeToSelectionEdge(time, selectionEdge = SELECTION_FROM) {
+    let selectionEdgeTimestamp;
+    let invertedComparison = false;
+    switch (selectionEdge) {
+      case SELECTION_FROM:
+        selectionEdgeTimestamp = __privateGet(this, _selectionStartTimestamp);
         break;
-      case at:
-        h = t(this, c), o = !0;
+      case SELECTION_TO:
+        selectionEdgeTimestamp = __privateGet(this, _selectionEndTimestamp);
+        invertedComparison = true;
         break;
     }
-    if (h === void 0)
+    if (selectionEdgeTimestamp === void 0)
       return 0;
-    const a = n(this, C, D).call(this, s, !1).reduce((f, I) => f + I, 0), d = this.getUnitsOffsetForTimestamp(h, a) * (o ? -1 : 1);
-    return d && (d > 0 ? 1 : -1);
-  }
-  updateSelection(s, i) {
-    const h = t(this, l), o = t(this, c), a = n(this, C, D).call(this, s, !1).reduce((d, f) => d + f, 0);
-    switch (i === dt && (a <= h ? i = at : a >= o && (i = Z)), i) {
-      case Z:
-        e(this, l, a), e(this, c, Math.max(t(this, l), o ?? a));
+    const timestamp = __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, time, false).reduce((a, b) => a + b, 0);
+    const timestampOffset = this.getUnitsOffsetForTimestamp(selectionEdgeTimestamp, timestamp) * (invertedComparison ? -1 : 1);
+    return timestampOffset && (timestampOffset > 0 ? 1 : -1);
+  }
+  updateSelection(time, selection) {
+    const currentStart = __privateGet(this, _selectionStartTimestamp);
+    const currentEnd = __privateGet(this, _selectionEndTimestamp);
+    const timestamp = __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, time, false).reduce((a, b) => a + b, 0);
+    if (selection === SELECTION_FARTHEST) {
+      if (timestamp <= currentStart)
+        selection = SELECTION_TO;
+      else if (timestamp >= currentEnd)
+        selection = SELECTION_FROM;
+    }
+    switch (selection) {
+      case SELECTION_FROM:
+        __privateSet(this, _selectionStartTimestamp, timestamp);
+        __privateSet(this, _selectionEndTimestamp, Math.max(__privateGet(this, _selectionStartTimestamp), currentEnd ?? timestamp));
         break;
-      case at:
-        e(this, c, a), e(this, l, Math.min(h ?? a, t(this, c)));
+      case SELECTION_TO:
+        __privateSet(this, _selectionEndTimestamp, timestamp);
+        __privateSet(this, _selectionStartTimestamp, Math.min(currentStart ?? timestamp, __privateGet(this, _selectionEndTimestamp)));
         break;
-      case dt:
-      case ut: {
-        let d = Math.abs(a - (h ?? a)), f = Math.abs(a - (o ?? a));
-        i === ut && ([d, f] = [f, d]), d > f ? e(this, l, a) : e(this, c, a);
+      case SELECTION_FARTHEST:
+      case SELECTION_NEAREST: {
+        let startDistance = Math.abs(timestamp - (currentStart ?? timestamp));
+        let endDistance = Math.abs(timestamp - (currentEnd ?? timestamp));
+        if (selection === SELECTION_NEAREST) {
+          [startDistance, endDistance] = [endDistance, startDistance];
+        }
+        if (startDistance > endDistance) {
+          __privateSet(this, _selectionStartTimestamp, timestamp);
+        } else
+          __privateSet(this, _selectionEndTimestamp, timestamp);
         break;
       }
-      case Mt:
+      case SELECTION_COLLAPSE:
       default:
-        e(this, l, e(this, c, a));
+        __privateSet(this, _selectionStartTimestamp, __privateSet(this, _selectionEndTimestamp, timestamp));
         break;
     }
-    (t(this, l) !== h || t(this, c) !== o) && this.refreshFrame(!0);
+    if (__privateGet(this, _selectionStartTimestamp) !== currentStart || __privateGet(this, _selectionEndTimestamp) !== currentEnd) {
+      this.refreshFrame(true);
+    }
   }
 };
-U = new WeakMap(), g = new WeakMap(), z = new WeakMap(), K = new WeakMap(), $ = new WeakMap(), V = new WeakMap(), T = new WeakMap(), F = new WeakMap(), A = new WeakMap(), v = new WeakMap(), L = new WeakMap(), N = new WeakMap(), _ = new WeakMap(), B = new WeakMap(), X = new WeakMap(), l = new WeakMap(), c = new WeakMap(), u = new WeakMap(), E = new WeakMap(), b = new WeakMap(), R = new WeakMap(), Y = new WeakMap(), j = new WeakMap(), y = new WeakMap(), S = new WeakMap(), q = new WeakMap(), G = new WeakMap(), st = new WeakMap(), it = new WeakMap(), et = new WeakSet(), Ot = function(s) {
-  return ot(t(this, y), s || 0, t(this, S) - t(this, u) + 1);
-}, C = new WeakSet(), D = function(s, i = !0) {
-  let h = new Date(s).getTime();
-  if (isNaN(h))
-    return n(this, C, D).call(this, Date.now());
-  const { from: o, to: a } = t(this, E), d = ot(o, h, a);
-  d !== h && i ? (h = Kt(o, a), (isNaN(h) || mt(h)) && (h = d)) : h = d;
-  const f = Et(h);
-  return [h - f, f];
-}, rt = new WeakSet(), Ft = function(s) {
-  if (gt(s) && s >= 0 && s < t(this, u)) {
-    if (!t(this, _)[s]) {
-      const i = this.getFrameBlockAtIndex(s);
-      if (!i)
-        return;
-      const h = `${i.year}-${`0${1 + i.month}`.slice(-2)}-01`, [o, a] = this.getFormattedDataForFrameBlock(new Date(h).setHours(12)), d = i.outer.from;
-      t(this, _)[s] = tt(
-        {
-          datetime: k(a),
-          label: k(o),
-          length: k(Math.ceil(i.outer.units / this.rowspan)),
-          month: k(i.month),
-          year: k(i.year)
-        },
-        (f) => {
-          const I = f * this.rowspan;
-          return tt(this.rowspan, (P) => {
-            const [W, Tt] = i[P + I], [kt, It] = this.getFormattedDataForBlockCell(new Date(W).setHours(12));
-            return $t({
-              datetime: k(It),
-              flags: k(Ht(Tt)),
-              index: k(d + P + I),
-              label: k(kt),
-              timestamp: k(W)
-            });
-          });
-        }
-      );
+_DEFAULT_LOCALE = new WeakMap();
+_cursorBlockIndex = new WeakMap();
+_cursorBlockStartIndex = new WeakMap();
+_cursorBlockEndIndex = new WeakMap();
+_cursorStartIndex = new WeakMap();
+_cursorEndIndex = new WeakMap();
+_cursorIndex = new WeakMap();
+_cursorOffset = new WeakMap();
+_cursorTimestamp = new WeakMap();
+_dynamicBlockHeight = new WeakMap();
+_effect = new WeakMap();
+_firstWeekDay = new WeakMap();
+_frameBlocksCached = new WeakMap();
+_locale = new WeakMap();
+_maxFrameSize = new WeakMap();
+_selectionStartTimestamp = new WeakMap();
+_selectionEndTimestamp = new WeakMap();
+_size = new WeakMap();
+_timeslice = new WeakMap();
+_today = new WeakMap();
+_unwatchCurrentDay = new WeakMap();
+_fromTimestamp = new WeakMap();
+_toTimestamp = new WeakMap();
+_fromBlockOffsetFromOrigin = new WeakMap();
+_toBlockOffsetFromOrigin = new WeakMap();
+_numberOfBlocks = new WeakMap();
+_numberOfUnits = new WeakMap();
+_daysOfWeek = new WeakMap();
+_frameBlocks = new WeakMap();
+_getClampedFrameOffset = new WeakSet();
+getClampedFrameOffset_fn = function(frameOffset) {
+  return clamp(__privateGet(this, _fromBlockOffsetFromOrigin), frameOffset || 0, __privateGet(this, _toBlockOffsetFromOrigin) - __privateGet(this, _size) + 1);
+};
+_getContainedTimestamp = new WeakSet();
+getContainedTimestamp_fn = function(time, withMidRangeFallback = true) {
+  let timestamp = new Date(time).getTime();
+  if (isNaN(timestamp))
+    return __privateMethod(this, _getContainedTimestamp, getContainedTimestamp_fn).call(this, Date.now());
+  const { from, to } = __privateGet(this, _timeslice);
+  const clampedTimestamp = clamp(from, timestamp, to);
+  if (clampedTimestamp !== timestamp && withMidRangeFallback) {
+    timestamp = mid(from, to);
+    if (isNaN(timestamp) || isInfinite(timestamp)) {
+      timestamp = clampedTimestamp;
     }
-    return t(this, _)[s];
-  }
-}, p = new WeakSet(), O = function(s) {
-  s !== 0 && (e(this, F, t(this, F) + s), this.refreshFrame());
-}, w = new WeakSet(), H = function(s) {
-  const i = n(this, et, Ot).call(this, s);
-  i && (this.shiftOrigin(i), e(this, y, t(this, y) - i), e(this, S, t(this, S) - i), e(this, g, Vt(t(this, g) - i, t(this, u))), this.refreshFrame());
-}, J = new WeakSet(), ft = function() {
-  const s = t(this, u) - 1, i = Math.min(s - this.origin % t(this, u), t(this, S)) - s;
-  i && n(this, w, H).call(this, i);
-}, r(x, U, "en-US");
-let pt = x;
+  } else
+    timestamp = clampedTimestamp;
+  const offset = computeTimestampOffset(timestamp);
+  return [timestamp - offset, offset];
+};
+_getFrameBlockAtIndex = new WeakSet();
+getFrameBlockAtIndex_fn = function(index) {
+  if (!(isBitSafeInteger(index) && index >= 0 && index < __privateGet(this, _size)))
+    return;
+  if (!__privateGet(this, _frameBlocksCached)[index]) {
+    const block = this.getFrameBlockAtIndex(index);
+    if (!block)
+      return void 0;
+    const dateString = `${block.year}-${`0${1 + block.month}`.slice(-2)}-01`;
+    const [label, datetime] = this.getFormattedDataForFrameBlock(new Date(dateString).setHours(12));
+    const blockStartIndex = block.outer.from;
+    __privateGet(this, _frameBlocksCached)[index] = indexed(
+      {
+        datetime: enumerable(datetime),
+        label: enumerable(label),
+        length: enumerable(Math.ceil(block.outer.units / this.rowspan)),
+        month: enumerable(block.month),
+        year: enumerable(block.year)
+      },
+      (index2) => {
+        const indexOffset = index2 * this.rowspan;
+        return indexed(this.rowspan, (index3) => {
+          const [timestamp, flags] = block[index3 + indexOffset];
+          const [label2, datetime2] = this.getFormattedDataForBlockCell(new Date(timestamp).setHours(12));
+          return struct({
+            datetime: enumerable(datetime2),
+            flags: enumerable(createFlagsRecord(flags)),
+            index: enumerable(blockStartIndex + index3 + indexOffset),
+            label: enumerable(label2),
+            timestamp: enumerable(timestamp)
+          });
+        });
+      }
+    );
+  }
+  return __privateGet(this, _frameBlocksCached)[index];
+};
+_shiftFrameCursorByOffset = new WeakSet();
+shiftFrameCursorByOffset_fn = function(offset) {
+  if (offset === 0)
+    return;
+  __privateSet(this, _cursorOffset, __privateGet(this, _cursorOffset) + offset);
+  this.refreshFrame();
+};
+_shiftOrigin = new WeakSet();
+shiftOrigin_fn = function(offset) {
+  const clampedOffset = __privateMethod(this, _getClampedFrameOffset, getClampedFrameOffset_fn).call(this, offset);
+  if (clampedOffset) {
+    this.shiftOrigin(clampedOffset);
+    __privateSet(this, _fromBlockOffsetFromOrigin, __privateGet(this, _fromBlockOffsetFromOrigin) - clampedOffset);
+    __privateSet(this, _toBlockOffsetFromOrigin, __privateGet(this, _toBlockOffsetFromOrigin) - clampedOffset);
+    __privateSet(this, _cursorBlockIndex, mod(__privateGet(this, _cursorBlockIndex) - clampedOffset, __privateGet(this, _size)));
+    this.refreshFrame();
+  }
+};
+_shiftOriginIfNecessary = new WeakSet();
+shiftOriginIfNecessary_fn = function() {
+  const size_1 = __privateGet(this, _size) - 1;
+  const offset = Math.min(size_1 - this.origin % __privateGet(this, _size), __privateGet(this, _toBlockOffsetFromOrigin)) - size_1;
+  if (offset)
+    __privateMethod(this, _shiftOrigin, shiftOrigin_fn).call(this, offset);
+};
+__privateAdd(_TimeFrame, _DEFAULT_LOCALE, "en-US");
+let TimeFrame = _TimeFrame;
 export {
-  pt as default
+  TimeFrame as default
 };