@adyen/adyen-platform-experience-web 1.0.0-beta → 1.0.0-beta.2

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

@@ -1,496 +1,316 @@
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
+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 __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))
+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))
     throw TypeError("Cannot add the same private member more than once");
-  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);
+  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);
   },
   get _() {
-    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 {
+    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 {
   constructor() {
-    __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)));
+    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)));
   }
   get fromTimestamp() {
-    return __privateGet(this, _fromTimestamp);
+    return t(this, Y);
   }
   get toTimestamp() {
-    return __privateGet(this, _toTimestamp);
+    return t(this, j);
   }
   get numberOfBlocks() {
-    return __privateGet(this, _numberOfBlocks);
+    return t(this, q);
   }
   get blankSelection() {
-    return __privateGet(this, _selectionStartTimestamp) === __privateGet(this, _selectionEndTimestamp) && __privateGet(this, _selectionEndTimestamp) === void 0;
+    return t(this, l) === t(this, c) && t(this, c) === void 0;
   }
   get cursor() {
-    return __privateGet(this, _cursorIndex) ?? -1;
+    return t(this, T) ?? -1;
   }
   get daysOfWeek() {
-    return __privateGet(this, _daysOfWeek);
+    return t(this, st);
   }
   get dynamicBlockHeight() {
-    return __privateGet(this, _dynamicBlockHeight);
+    return t(this, v);
   }
-  set dynamicBlockHeight(bool) {
-    if (bool == void 0)
-      __privateSet(this, _dynamicBlockHeight, !!bool);
-    else if (bool === Boolean(bool))
-      __privateSet(this, _dynamicBlockHeight, bool);
+  set dynamicBlockHeight(s) {
+    s == null ? e(this, v, !!s) : s === !!s && e(this, v, s);
   }
-  set effect(effect) {
-    if (effect == void 0)
-      __privateSet(this, _effect, void 0);
-    else if (isFunction(effect))
-      __privateSet(this, _effect, effect);
+  set effect(s) {
+    s == null ? e(this, L, void 0) : zt(s) && e(this, L, s);
   }
   get firstWeekDay() {
-    return __privateGet(this, _firstWeekDay);
+    return t(this, N);
   }
-  set firstWeekDay(day) {
-    if (day != void 0) {
-      if (!FIRST_WEEK_DAYS.includes(day))
-        return;
-      if (__privateGet(this, _firstWeekDay) === __privateSet(this, _firstWeekDay, day))
+  set firstWeekDay(s) {
+    if (s != null) {
+      if (!Rt.includes(s) || t(this, N) === e(this, N, s))
         return;
     } else
       this.firstWeekDay = 0;
   }
   get frameBlocks() {
-    return __privateGet(this, _frameBlocks);
+    return t(this, it);
   }
   get isAtEnd() {
-    return !isInfinite(__privateGet(this, _toBlockOffsetFromOrigin)) && __privateGet(this, _toBlockOffsetFromOrigin) === __privateGet(this, _size) - 1;
+    return !mt(t(this, S)) && t(this, S) === t(this, u) - 1;
   }
   get isAtStart() {
-    return !isInfinite(__privateGet(this, _fromBlockOffsetFromOrigin)) && __privateGet(this, _fromBlockOffsetFromOrigin) === 0;
+    return !mt(t(this, y)) && t(this, y) === 0;
   }
   get locale() {
-    return __privateGet(this, _locale);
+    return t(this, B);
   }
-  set locale(locale) {
-    const currentLocale = __privateGet(this, _locale);
-    if (locale == void 0) {
-      __privateSet(this, _locale, __privateGet(_TimeFrame, _DEFAULT_LOCALE));
-    } else if (typeof Intl !== "undefined") {
+  set locale(s) {
+    const i = t(this, B);
+    if (s == null)
+      e(this, B, t(x, U));
+    else if (typeof Intl < "u")
       try {
-        __privateSet(this, _locale, new Intl.Locale(locale).toString());
+        e(this, B, new Intl.Locale(s).toString());
       } catch {
-        __privateSet(this, _locale, __privateGet(_TimeFrame, _DEFAULT_LOCALE));
+        e(this, B, t(x, U));
       }
-    }
-    if (__privateGet(this, _locale) !== currentLocale)
-      this.refreshFrame(true);
+    t(this, B) !== i && this.refreshFrame(!0);
   }
   get selectionStart() {
-    return __privateGet(this, _selectionStartTimestamp);
+    return t(this, l);
   }
   get selectionEnd() {
-    return __privateGet(this, _selectionEndTimestamp);
+    return t(this, c);
   }
   get size() {
-    return __privateGet(this, _size);
+    return t(this, u);
   }
-  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();
+  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());
   }
   get timeslice() {
-    return __privateGet(this, _timeslice);
+    return t(this, E);
   }
-  set timeslice(timeslice) {
-    if (timeslice === __privateGet(this, _timeslice) || timeslice == void 0 && __privateGet(this, _timeslice) === UNBOUNDED_SLICE)
+  set timeslice(s) {
+    if (s === t(this, E) || s == null && t(this, E) === lt)
       return;
-    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;
+    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);
   }
   get units() {
-    return __privateGet(this, _numberOfUnits);
+    return t(this, G);
   }
   initialize() {
-    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), 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);
-    (_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:
+    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:
         default:
-          return __privateMethod(this, _shiftOrigin, shiftOrigin_fn).call(this, offset * __privateGet(this, _size));
+          return n(this, w, H).call(this, s * t(this, u));
       }
-    }
   }
-  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));
+  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));
     }
+    if (!(s < 0) && s >= t(this, $) && s <= t(this, V))
+      return n(this, p, O).call(this, s - t(this, T));
   }
-  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));
+  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));
   }
   clearSelection() {
-    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);
+    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);
         break;
-      case SELECTION_TO:
-        selectionEdgeTimestamp = __privateGet(this, _selectionEndTimestamp);
-        invertedComparison = true;
+      case at:
+        h = t(this, c), o = !0;
         break;
     }
-    if (selectionEdgeTimestamp === void 0)
+    if (h === void 0)
       return 0;
-    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));
+    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));
         break;
-      case SELECTION_TO:
-        __privateSet(this, _selectionEndTimestamp, timestamp);
-        __privateSet(this, _selectionStartTimestamp, Math.min(currentStart ?? timestamp, __privateGet(this, _selectionEndTimestamp)));
+      case at:
+        e(this, c, a), e(this, l, Math.min(h ?? a, t(this, c)));
         break;
-      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);
+      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);
         break;
       }
-      case SELECTION_COLLAPSE:
+      case Mt:
       default:
-        __privateSet(this, _selectionStartTimestamp, __privateSet(this, _selectionEndTimestamp, timestamp));
+        e(this, l, e(this, c, a));
         break;
     }
-    if (__privateGet(this, _selectionStartTimestamp) !== currentStart || __privateGet(this, _selectionEndTimestamp) !== currentEnd) {
-      this.refreshFrame(true);
-    }
+    (t(this, l) !== h || t(this, c) !== o) && this.refreshFrame(!0);
   }
 };
-_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;
-    }
-  } 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)
+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)
+            });
           });
-        });
-      }
-    );
-  }
-  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;
+        }
+      );
+    }
+    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;
 export {
-  TimeFrame as default
+  pt as default
 };