@vestcards/shared 0.5.1 → 1.0.1

package/dist/spaced-repetition.js

@@ -0,0 +1,1195 @@
+var Oe = Object.defineProperty;
+var Fe = (t, e, i) => e in t ? Oe(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
+var _ = (t, e, i) => Fe(t, typeof e != "symbol" ? e + "" : e, i);
+import { r as V, a as Ne, b as fe } from "./fsrs-C8QUsZ5l.js";
+import "date-fns/locale";
+import { isSameDay as Ie } from "date-fns";
+import "date-fns-tz";
+const Pe = 0.9, Ft = 50, Nt = 200, It = 10, Pt = 10;
+var h = ((t) => (t[t.New = 0] = "New", t[t.Learning = 1] = "Learning", t[t.Review = 2] = "Review", t[t.Relearning = 3] = "Relearning", t))(h || {}), l = ((t) => (t[t.Manual = 0] = "Manual", t[t.Again = 1] = "Again", t[t.Hard = 2] = "Hard", t[t.Good = 3] = "Good", t[t.Easy = 4] = "Easy", t))(l || {});
+class d {
+  static card(e) {
+    return { ...e, state: d.state(e.state), due: d.time(e.due), last_review: e.last_review ? d.time(e.last_review) : void 0 };
+  }
+  static rating(e) {
+    if (typeof e == "string") {
+      const i = e.charAt(0).toUpperCase(), r = e.slice(1).toLowerCase(), s = l[`${i}${r}`];
+      if (s === void 0) throw new Error(`Invalid rating:[${e}]`);
+      return s;
+    } else if (typeof e == "number") return e;
+    throw new Error(`Invalid rating:[${e}]`);
+  }
+  static state(e) {
+    if (typeof e == "string") {
+      const i = e.charAt(0).toUpperCase(), r = e.slice(1).toLowerCase(), s = h[`${i}${r}`];
+      if (s === void 0) throw new Error(`Invalid state:[${e}]`);
+      return s;
+    } else if (typeof e == "number") return e;
+    throw new Error(`Invalid state:[${e}]`);
+  }
+  static time(e) {
+    if (typeof e == "object" && e instanceof Date) return e;
+    if (typeof e == "string") {
+      const i = Date.parse(e);
+      if (isNaN(i)) throw new Error(`Invalid date:[${e}]`);
+      return new Date(i);
+    } else if (typeof e == "number") return new Date(e);
+    throw new Error(`Invalid date:[${e}]`);
+  }
+  static review_log(e) {
+    return { ...e, due: d.time(e.due), rating: d.rating(e.rating), state: d.state(e.state), review: d.time(e.review) };
+  }
+}
+Date.prototype.scheduler = function(t, e) {
+  return Ae(this, t, e);
+}, Date.prototype.diff = function(t, e) {
+  return Te(this, t, e);
+}, Date.prototype.format = function() {
+  return ke(this);
+}, Date.prototype.dueFormat = function(t, e, i) {
+  return je(this, t, e, i);
+};
+function Ae(t, e, i) {
+  return new Date(i ? d.time(t).getTime() + e * 24 * 60 * 60 * 1e3 : d.time(t).getTime() + e * 60 * 1e3);
+}
+function Te(t, e, i) {
+  if (!t || !e) throw new Error("Invalid date");
+  const r = d.time(t).getTime() - d.time(e).getTime();
+  let s = 0;
+  switch (i) {
+    case "days":
+      s = Math.floor(r / (1440 * 60 * 1e3));
+      break;
+    case "minutes":
+      s = Math.floor(r / (60 * 1e3));
+      break;
+  }
+  return s;
+}
+function ke(t) {
+  const e = d.time(t), i = e.getFullYear(), r = e.getMonth() + 1, s = e.getDate(), n = e.getHours(), a = e.getMinutes(), o = e.getSeconds();
+  return `${i}-${D(r)}-${D(s)} ${D(n)}:${D(a)}:${D(o)}`;
+}
+function D(t) {
+  return t < 10 ? `0${t}` : `${t}`;
+}
+const L = [60, 60, 24, 31, 12], G = ["second", "min", "hour", "day", "month", "year"];
+function je(t, e, i, r = G) {
+  t = d.time(t), e = d.time(e), r.length !== G.length && (r = G);
+  let s = t.getTime() - e.getTime(), n;
+  for (s /= 1e3, n = 0; n < L.length && !(s < L[n]); n++) s /= L[n];
+  return `${Math.floor(s)}${i ? r[n] : ""}`;
+}
+const he = Object.freeze([l.Again, l.Hard, l.Good, l.Easy]), He = [{ start: 2.5, end: 7, factor: 0.15 }, { start: 7, end: 20, factor: 0.1 }, { start: 20, end: 1 / 0, factor: 0.05 }];
+function $e(t, e, i) {
+  let r = 1;
+  for (const a of He) r += a.factor * Math.max(Math.min(t, a.end) - a.start, 0);
+  t = Math.min(t, i);
+  let s = Math.max(2, Math.round(t - r));
+  const n = Math.min(Math.round(t + r), i);
+  return t > e && (s = Math.max(s, e + 1)), s = Math.min(s, n), { min_ivl: s, max_ivl: n };
+}
+function b(t, e, i) {
+  return Math.min(Math.max(t, e), i);
+}
+function Le(t, e) {
+  const i = Date.UTC(t.getUTCFullYear(), t.getUTCMonth(), t.getUTCDate()), r = Date.UTC(e.getUTCFullYear(), e.getUTCMonth(), e.getUTCDate());
+  return Math.floor((r - i) / 864e5);
+}
+const Ge = 0.9, Ue = 36500, qe = Object.freeze([0.40255, 1.18385, 3.173, 15.69105, 7.1949, 0.5345, 1.4604, 46e-4, 1.54575, 0.1192, 1.01925, 1.9395, 0.11, 0.29605, 2.2698, 0.2315, 2.9898, 0.51655, 0.6621]), We = !1, Ye = !0, p = 0.01, N = 100, ie = Object.freeze([Object.freeze([p, N]), Object.freeze([p, N]), Object.freeze([p, N]), Object.freeze([p, N]), Object.freeze([1, 10]), Object.freeze([1e-3, 4]), Object.freeze([1e-3, 4]), Object.freeze([1e-3, 0.75]), Object.freeze([0, 4.5]), Object.freeze([0, 0.8]), Object.freeze([1e-3, 3.5]), Object.freeze([1e-3, 5]), Object.freeze([1e-3, 0.25]), Object.freeze([1e-3, 0.9]), Object.freeze([0, 4]), Object.freeze([0, 1]), Object.freeze([1, 6]), Object.freeze([0, 2]), Object.freeze([0, 2])]), W = (t) => {
+  let e = [...qe];
+  return t != null && t.w && (t.w.length === 19 ? e = [...t.w] : t.w.length === 17 && (e = t == null ? void 0 : t.w.concat([0, 0]), e[4] = +(e[5] * 2 + e[4]).toFixed(8), e[5] = +(Math.log(e[5] * 3 + 1) / 3).toFixed(8), e[6] = +(e[6] + 0.5).toFixed(8), console.debug("[FSRS V5]auto fill w to 19 length"))), e = e.map((i, r) => b(i, ie[r][0], ie[r][1])), { request_retention: (t == null ? void 0 : t.request_retention) || Ge, maximum_interval: (t == null ? void 0 : t.maximum_interval) || Ue, w: e, enable_fuzz: (t == null ? void 0 : t.enable_fuzz) ?? We, enable_short_term: (t == null ? void 0 : t.enable_short_term) ?? Ye };
+};
+function P(t, e) {
+  const i = { due: t ? d.time(t) : /* @__PURE__ */ new Date(), stability: 0, difficulty: 0, elapsed_days: 0, scheduled_days: 0, reps: 0, lapses: 0, state: h.New, last_review: void 0 };
+  return e && typeof e == "function" ? e(i) : i;
+}
+class Ke {
+  constructor(e) {
+    _(this, "c");
+    _(this, "s0");
+    _(this, "s1");
+    _(this, "s2");
+    const i = Be();
+    this.c = 1, this.s0 = i(" "), this.s1 = i(" "), this.s2 = i(" "), e == null && (e = +/* @__PURE__ */ new Date()), this.s0 -= i(e), this.s0 < 0 && (this.s0 += 1), this.s1 -= i(e), this.s1 < 0 && (this.s1 += 1), this.s2 -= i(e), this.s2 < 0 && (this.s2 += 1);
+  }
+  next() {
+    const e = 2091639 * this.s0 + this.c * 23283064365386963e-26;
+    return this.s0 = this.s1, this.s1 = this.s2, this.s2 = e - (this.c = e | 0), this.s2;
+  }
+  set state(e) {
+    this.c = e.c, this.s0 = e.s0, this.s1 = e.s1, this.s2 = e.s2;
+  }
+  get state() {
+    return { c: this.c, s0: this.s0, s1: this.s1, s2: this.s2 };
+  }
+}
+function Be() {
+  let t = 4022871197;
+  return function(e) {
+    e = String(e);
+    for (let i = 0; i < e.length; i++) {
+      t += e.charCodeAt(i);
+      let r = 0.02519603282416938 * t;
+      t = r >>> 0, r -= t, r *= t, t = r >>> 0, r -= t, t += r * 4294967296;
+    }
+    return (t >>> 0) * 23283064365386963e-26;
+  };
+}
+function Xe(t) {
+  const e = new Ke(t), i = () => e.next();
+  return i.int32 = () => e.next() * 4294967296 | 0, i.double = () => i() + (i() * 2097152 | 0) * 11102230246251565e-32, i.state = () => e.state, i.importState = (r) => (e.state = r, i), i;
+}
+const _e = -0.5, ye = 19 / 81;
+function Ze(t, e) {
+  return +Math.pow(1 + ye * t / e, _e).toFixed(8);
+}
+class Je {
+  constructor(e) {
+    _(this, "param");
+    _(this, "intervalModifier");
+    _(this, "_seed");
+    _(this, "forgetting_curve", Ze);
+    this.param = new Proxy(W(e), this.params_handler_proxy()), this.intervalModifier = this.calculate_interval_modifier(this.param.request_retention);
+  }
+  get interval_modifier() {
+    return this.intervalModifier;
+  }
+  set seed(e) {
+    this._seed = e;
+  }
+  calculate_interval_modifier(e) {
+    if (e <= 0 || e > 1) throw new Error("Requested retention rate should be in the range (0,1]");
+    return +((Math.pow(e, 1 / _e) - 1) / ye).toFixed(8);
+  }
+  get parameters() {
+    return this.param;
+  }
+  set parameters(e) {
+    this.update_parameters(e);
+  }
+  params_handler_proxy() {
+    const e = this;
+    return { set: function(i, r, s) {
+      return r === "request_retention" && Number.isFinite(s) && (e.intervalModifier = e.calculate_interval_modifier(Number(s))), Reflect.set(i, r, s), !0;
+    } };
+  }
+  update_parameters(e) {
+    const i = W(e);
+    for (const r in i) if (r in this.param) {
+      const s = r;
+      this.param[s] = i[s];
+    }
+  }
+  init_stability(e) {
+    return Math.max(this.param.w[e - 1], 0.1);
+  }
+  init_difficulty(e) {
+    return this.constrain_difficulty(this.param.w[4] - Math.exp((e - 1) * this.param.w[5]) + 1);
+  }
+  apply_fuzz(e, i) {
+    if (!this.param.enable_fuzz || e < 2.5) return Math.round(e);
+    const r = Xe(this._seed)(), { min_ivl: s, max_ivl: n } = $e(e, i, this.param.maximum_interval);
+    return Math.floor(r * (n - s + 1) + s);
+  }
+  next_interval(e, i) {
+    const r = Math.min(Math.max(1, Math.round(e * this.intervalModifier)), this.param.maximum_interval);
+    return this.apply_fuzz(r, i);
+  }
+  linear_damping(e, i) {
+    return +(e * (10 - i) / 9).toFixed(8);
+  }
+  next_difficulty(e, i) {
+    const r = -this.param.w[6] * (i - 3), s = e + this.linear_damping(r, e);
+    return this.constrain_difficulty(this.mean_reversion(this.init_difficulty(l.Easy), s));
+  }
+  constrain_difficulty(e) {
+    return Math.min(Math.max(+e.toFixed(8), 1), 10);
+  }
+  mean_reversion(e, i) {
+    return +(this.param.w[7] * e + (1 - this.param.w[7]) * i).toFixed(8);
+  }
+  next_recall_stability(e, i, r, s) {
+    const n = l.Hard === s ? this.param.w[15] : 1, a = l.Easy === s ? this.param.w[16] : 1;
+    return +b(i * (1 + Math.exp(this.param.w[8]) * (11 - e) * Math.pow(i, -this.param.w[9]) * (Math.exp((1 - r) * this.param.w[10]) - 1) * n * a), p, 36500).toFixed(8);
+  }
+  next_forget_stability(e, i, r) {
+    return +b(this.param.w[11] * Math.pow(e, -this.param.w[12]) * (Math.pow(i + 1, this.param.w[13]) - 1) * Math.exp((1 - r) * this.param.w[14]), p, 36500).toFixed(8);
+  }
+  next_short_term_stability(e, i) {
+    return +b(e * Math.exp(this.param.w[17] * (i - 3 + this.param.w[18])), p, 36500).toFixed(8);
+  }
+  next_state(e, i, r) {
+    const { difficulty: s, stability: n } = e ?? { difficulty: 0, stability: 0 };
+    if (i < 0) throw new Error(`Invalid delta_t "${i}"`);
+    if (r < 0 || r > 4) throw new Error(`Invalid grade "${r}"`);
+    if (s === 0 && n === 0) return { difficulty: this.init_difficulty(r), stability: this.init_stability(r) };
+    if (r === 0) return { difficulty: s, stability: n };
+    if (s < 1 || n < p) throw new Error(`Invalid memory state { difficulty: ${s}, stability: ${n} }`);
+    const a = this.forgetting_curve(i, n), o = this.next_recall_stability(s, n, a, r), c = this.next_forget_stability(s, n, a), u = this.next_short_term_stability(n, r);
+    let f = o;
+    if (r === 1) {
+      let [y, g] = [0, 0];
+      this.param.enable_short_term && (y = this.param.w[17], g = this.param.w[18]);
+      const E = n / Math.exp(y * g);
+      f = b(+E.toFixed(8), p, c);
+    }
+    return i === 0 && this.param.enable_short_term && (f = u), { difficulty: this.next_difficulty(s, r), stability: f };
+  }
+}
+function me() {
+  const t = this.review_time.getTime(), e = this.current.reps, i = this.current.difficulty * this.current.stability;
+  return `${t}_${e}_${i}`;
+}
+var Y = ((t) => (t.SCHEDULER = "Scheduler", t.SEED = "Seed", t))(Y || {});
+class we {
+  constructor(e, i, r, s = { seed: me }) {
+    _(this, "last");
+    _(this, "current");
+    _(this, "review_time");
+    _(this, "next", /* @__PURE__ */ new Map());
+    _(this, "algorithm");
+    _(this, "initSeedStrategy");
+    this.algorithm = r, this.initSeedStrategy = s.seed.bind(this), this.last = d.card(e), this.current = d.card(e), this.review_time = d.time(i), this.init();
+  }
+  init() {
+    const { state: e, last_review: i } = this.current;
+    let r = 0;
+    e !== h.New && i && (r = Le(i, this.review_time)), this.current.last_review = this.review_time, this.current.elapsed_days = r, this.current.reps += 1, this.algorithm.seed = this.initSeedStrategy();
+  }
+  preview() {
+    return { [l.Again]: this.review(l.Again), [l.Hard]: this.review(l.Hard), [l.Good]: this.review(l.Good), [l.Easy]: this.review(l.Easy), [Symbol.iterator]: this.previewIterator.bind(this) };
+  }
+  *previewIterator() {
+    for (const e of he) yield this.review(e);
+  }
+  review(e) {
+    const { state: i } = this.last;
+    let r;
+    switch (i) {
+      case h.New:
+        r = this.newState(e);
+        break;
+      case h.Learning:
+      case h.Relearning:
+        r = this.learningState(e);
+        break;
+      case h.Review:
+        r = this.reviewState(e);
+        break;
+    }
+    if (r) return r;
+    throw new Error("Invalid grade");
+  }
+  buildLog(e) {
+    const { last_review: i, due: r, elapsed_days: s } = this.last;
+    return { rating: e, state: this.current.state, due: i || r, stability: this.current.stability, difficulty: this.current.difficulty, elapsed_days: this.current.elapsed_days, last_elapsed_days: s, scheduled_days: this.current.scheduled_days, review: this.review_time };
+  }
+}
+class re extends we {
+  newState(e) {
+    const i = this.next.get(e);
+    if (i) return i;
+    const r = d.card(this.current);
+    switch (r.difficulty = this.algorithm.init_difficulty(e), r.stability = this.algorithm.init_stability(e), e) {
+      case l.Again:
+        r.scheduled_days = 0, r.due = this.review_time.scheduler(1), r.state = h.Learning;
+        break;
+      case l.Hard:
+        r.scheduled_days = 0, r.due = this.review_time.scheduler(5), r.state = h.Learning;
+        break;
+      case l.Good:
+        r.scheduled_days = 0, r.due = this.review_time.scheduler(10), r.state = h.Learning;
+        break;
+      case l.Easy: {
+        const n = this.algorithm.next_interval(r.stability, this.current.elapsed_days);
+        r.scheduled_days = n, r.due = this.review_time.scheduler(n, !0), r.state = h.Review;
+        break;
+      }
+      default:
+        throw new Error("Invalid grade");
+    }
+    const s = { card: r, log: this.buildLog(e) };
+    return this.next.set(e, s), s;
+  }
+  learningState(e) {
+    const i = this.next.get(e);
+    if (i) return i;
+    const { state: r, difficulty: s, stability: n } = this.last, a = d.card(this.current), o = this.current.elapsed_days;
+    switch (a.difficulty = this.algorithm.next_difficulty(s, e), a.stability = this.algorithm.next_short_term_stability(n, e), e) {
+      case l.Again: {
+        a.scheduled_days = 0, a.due = this.review_time.scheduler(5, !1), a.state = r;
+        break;
+      }
+      case l.Hard: {
+        a.scheduled_days = 0, a.due = this.review_time.scheduler(10), a.state = r;
+        break;
+      }
+      case l.Good: {
+        const u = this.algorithm.next_interval(a.stability, o);
+        a.scheduled_days = u, a.due = this.review_time.scheduler(u, !0), a.state = h.Review;
+        break;
+      }
+      case l.Easy: {
+        const u = this.algorithm.next_short_term_stability(n, l.Good), f = this.algorithm.next_interval(u, o), y = Math.max(this.algorithm.next_interval(a.stability, o), f + 1);
+        a.scheduled_days = y, a.due = this.review_time.scheduler(y, !0), a.state = h.Review;
+        break;
+      }
+      default:
+        throw new Error("Invalid grade");
+    }
+    const c = { card: a, log: this.buildLog(e) };
+    return this.next.set(e, c), c;
+  }
+  reviewState(e) {
+    const i = this.next.get(e);
+    if (i) return i;
+    const r = this.current.elapsed_days, { difficulty: s, stability: n } = this.last, a = this.algorithm.forgetting_curve(r, n), o = d.card(this.current), c = d.card(this.current), u = d.card(this.current), f = d.card(this.current);
+    this.next_ds(o, c, u, f, s, n, a), this.next_interval(o, c, u, f, r), this.next_state(o, c, u, f), o.lapses += 1;
+    const y = { card: o, log: this.buildLog(l.Again) }, g = { card: c, log: super.buildLog(l.Hard) }, E = { card: u, log: super.buildLog(l.Good) }, R = { card: f, log: super.buildLog(l.Easy) };
+    return this.next.set(l.Again, y), this.next.set(l.Hard, g), this.next.set(l.Good, E), this.next.set(l.Easy, R), this.next.get(e);
+  }
+  next_ds(e, i, r, s, n, a, o) {
+    e.difficulty = this.algorithm.next_difficulty(n, l.Again);
+    const c = a / Math.exp(this.algorithm.parameters.w[17] * this.algorithm.parameters.w[18]), u = this.algorithm.next_forget_stability(n, a, o);
+    e.stability = b(+c.toFixed(8), p, u), i.difficulty = this.algorithm.next_difficulty(n, l.Hard), i.stability = this.algorithm.next_recall_stability(n, a, o, l.Hard), r.difficulty = this.algorithm.next_difficulty(n, l.Good), r.stability = this.algorithm.next_recall_stability(n, a, o, l.Good), s.difficulty = this.algorithm.next_difficulty(n, l.Easy), s.stability = this.algorithm.next_recall_stability(n, a, o, l.Easy);
+  }
+  next_interval(e, i, r, s, n) {
+    let a, o;
+    a = this.algorithm.next_interval(i.stability, n), o = this.algorithm.next_interval(r.stability, n), a = Math.min(a, o), o = Math.max(o, a + 1);
+    const c = Math.max(this.algorithm.next_interval(s.stability, n), o + 1);
+    e.scheduled_days = 0, e.due = this.review_time.scheduler(5), i.scheduled_days = a, i.due = this.review_time.scheduler(a, !0), r.scheduled_days = o, r.due = this.review_time.scheduler(o, !0), s.scheduled_days = c, s.due = this.review_time.scheduler(c, !0);
+  }
+  next_state(e, i, r, s) {
+    e.state = h.Relearning, i.state = h.Review, r.state = h.Review, s.state = h.Review;
+  }
+}
+class se extends we {
+  newState(e) {
+    const i = this.next.get(e);
+    if (i) return i;
+    this.current.scheduled_days = 0, this.current.elapsed_days = 0;
+    const r = d.card(this.current), s = d.card(this.current), n = d.card(this.current), a = d.card(this.current);
+    return this.init_ds(r, s, n, a), this.next_interval(r, s, n, a, 0), this.next_state(r, s, n, a), this.update_next(r, s, n, a), this.next.get(e);
+  }
+  init_ds(e, i, r, s) {
+    e.difficulty = this.algorithm.init_difficulty(l.Again), e.stability = this.algorithm.init_stability(l.Again), i.difficulty = this.algorithm.init_difficulty(l.Hard), i.stability = this.algorithm.init_stability(l.Hard), r.difficulty = this.algorithm.init_difficulty(l.Good), r.stability = this.algorithm.init_stability(l.Good), s.difficulty = this.algorithm.init_difficulty(l.Easy), s.stability = this.algorithm.init_stability(l.Easy);
+  }
+  learningState(e) {
+    return this.reviewState(e);
+  }
+  reviewState(e) {
+    const i = this.next.get(e);
+    if (i) return i;
+    const r = this.current.elapsed_days, { difficulty: s, stability: n } = this.last, a = this.algorithm.forgetting_curve(r, n), o = d.card(this.current), c = d.card(this.current), u = d.card(this.current), f = d.card(this.current);
+    return this.next_ds(o, c, u, f, s, n, a), this.next_interval(o, c, u, f, r), this.next_state(o, c, u, f), o.lapses += 1, this.update_next(o, c, u, f), this.next.get(e);
+  }
+  next_ds(e, i, r, s, n, a, o) {
+    e.difficulty = this.algorithm.next_difficulty(n, l.Again);
+    const c = this.algorithm.next_forget_stability(n, a, o);
+    e.stability = b(a, p, c), i.difficulty = this.algorithm.next_difficulty(n, l.Hard), i.stability = this.algorithm.next_recall_stability(n, a, o, l.Hard), r.difficulty = this.algorithm.next_difficulty(n, l.Good), r.stability = this.algorithm.next_recall_stability(n, a, o, l.Good), s.difficulty = this.algorithm.next_difficulty(n, l.Easy), s.stability = this.algorithm.next_recall_stability(n, a, o, l.Easy);
+  }
+  next_interval(e, i, r, s, n) {
+    let a, o, c, u;
+    a = this.algorithm.next_interval(e.stability, n), o = this.algorithm.next_interval(i.stability, n), c = this.algorithm.next_interval(r.stability, n), u = this.algorithm.next_interval(s.stability, n), a = Math.min(a, o), o = Math.max(o, a + 1), c = Math.max(c, o + 1), u = Math.max(u, c + 1), e.scheduled_days = a, e.due = this.review_time.scheduler(a, !0), i.scheduled_days = o, i.due = this.review_time.scheduler(o, !0), r.scheduled_days = c, r.due = this.review_time.scheduler(c, !0), s.scheduled_days = u, s.due = this.review_time.scheduler(u, !0);
+  }
+  next_state(e, i, r, s) {
+    e.state = h.Review, i.state = h.Review, r.state = h.Review, s.state = h.Review;
+  }
+  update_next(e, i, r, s) {
+    const n = { card: e, log: this.buildLog(l.Again) }, a = { card: i, log: super.buildLog(l.Hard) }, o = { card: r, log: super.buildLog(l.Good) }, c = { card: s, log: super.buildLog(l.Easy) };
+    this.next.set(l.Again, n), this.next.set(l.Hard, a), this.next.set(l.Good, o), this.next.set(l.Easy, c);
+  }
+}
+class Qe {
+  constructor(e) {
+    _(this, "fsrs");
+    this.fsrs = e;
+  }
+  replay(e, i, r) {
+    return this.fsrs.next(e, i, r);
+  }
+  handleManualRating(e, i, r, s, n, a, o) {
+    if (typeof i > "u") throw new Error("reschedule: state is required for manual rating");
+    let c, u;
+    if (i === h.New) c = { rating: l.Manual, state: i, due: o ?? r, stability: e.stability, difficulty: e.difficulty, elapsed_days: s, last_elapsed_days: e.elapsed_days, scheduled_days: e.scheduled_days, review: r }, u = P(r), u.last_review = r;
+    else {
+      if (typeof o > "u") throw new Error("reschedule: due is required for manual rating");
+      const f = o.diff(r, "days");
+      c = { rating: l.Manual, state: e.state, due: e.last_review || e.due, stability: e.stability, difficulty: e.difficulty, elapsed_days: s, last_elapsed_days: e.elapsed_days, scheduled_days: e.scheduled_days, review: r }, u = { ...e, state: i, due: o, last_review: r, stability: n || e.stability, difficulty: a || e.difficulty, elapsed_days: s, scheduled_days: f, reps: e.reps + 1 };
+    }
+    return { card: u, log: c };
+  }
+  reschedule(e, i) {
+    const r = [];
+    let s = P(e.due);
+    for (const n of i) {
+      let a;
+      if (n.review = d.time(n.review), n.rating === l.Manual) {
+        let o = 0;
+        s.state !== h.New && s.last_review && (o = n.review.diff(s.last_review, "days")), a = this.handleManualRating(s, n.state, n.review, o, n.stability, n.difficulty, n.due ? d.time(n.due) : void 0);
+      } else a = this.replay(s, n.review, n.rating);
+      r.push(a), s = a.card;
+    }
+    return r;
+  }
+  calculateManualRecord(e, i, r, s) {
+    if (!r) return null;
+    const { card: n, log: a } = r, o = d.card(e);
+    return o.due.getTime() === n.due.getTime() ? null : (o.scheduled_days = n.due.diff(o.due, "days"), this.handleManualRating(o, n.state, d.time(i), a.elapsed_days, s ? n.stability : void 0, s ? n.difficulty : void 0, n.due));
+  }
+}
+class Ve extends Je {
+  constructor(i) {
+    super(i);
+    _(this, "strategyHandler", /* @__PURE__ */ new Map());
+    _(this, "Scheduler");
+    const { enable_short_term: r } = this.parameters;
+    this.Scheduler = r ? re : se;
+  }
+  params_handler_proxy() {
+    const i = this;
+    return { set: function(r, s, n) {
+      return s === "request_retention" && Number.isFinite(n) ? i.intervalModifier = i.calculate_interval_modifier(Number(n)) : s === "enable_short_term" && (i.Scheduler = n === !0 ? re : se), Reflect.set(r, s, n), !0;
+    } };
+  }
+  useStrategy(i, r) {
+    return this.strategyHandler.set(i, r), this;
+  }
+  clearStrategy(i) {
+    return i ? this.strategyHandler.delete(i) : this.strategyHandler.clear(), this;
+  }
+  getScheduler(i, r) {
+    const s = this.strategyHandler.get(Y.SEED), n = this.strategyHandler.get(Y.SCHEDULER) || this.Scheduler, a = s || me;
+    return new n(i, r, this, { seed: a });
+  }
+  repeat(i, r, s) {
+    const n = this.getScheduler(i, r).preview();
+    return s && typeof s == "function" ? s(n) : n;
+  }
+  next(i, r, s, n) {
+    const a = this.getScheduler(i, r), o = d.rating(s);
+    if (o === l.Manual) throw new Error("Cannot review a manual rating");
+    const c = a.review(o);
+    return n && typeof n == "function" ? n(c) : c;
+  }
+  get_retrievability(i, r, s = !0) {
+    const n = d.card(i);
+    r = r ? d.time(r) : /* @__PURE__ */ new Date();
+    const a = n.state !== h.New ? Math.max(r.diff(n.last_review, "days"), 0) : 0, o = n.state !== h.New ? this.forgetting_curve(a, +n.stability.toFixed(8)) : 0;
+    return s ? `${(o * 100).toFixed(2)}%` : o;
+  }
+  rollback(i, r, s) {
+    const n = d.card(i), a = d.review_log(r);
+    if (a.rating === l.Manual) throw new Error("Cannot rollback a manual rating");
+    let o, c, u;
+    switch (a.state) {
+      case h.New:
+        o = a.due, c = void 0, u = 0;
+        break;
+      case h.Learning:
+      case h.Relearning:
+      case h.Review:
+        o = a.review, c = a.due, u = n.lapses - (a.rating === l.Again && a.state === h.Review ? 1 : 0);
+        break;
+    }
+    const f = { ...n, due: o, stability: a.stability, difficulty: a.difficulty, elapsed_days: a.last_elapsed_days, scheduled_days: a.scheduled_days, reps: Math.max(0, n.reps - 1), lapses: Math.max(0, u), state: a.state, last_review: c };
+    return s && typeof s == "function" ? s(f) : f;
+  }
+  forget(i, r, s = !1, n) {
+    const a = d.card(i);
+    r = d.time(r);
+    const o = a.state === h.New ? 0 : r.diff(a.last_review, "days"), c = { rating: l.Manual, state: a.state, due: a.due, stability: a.stability, difficulty: a.difficulty, elapsed_days: 0, last_elapsed_days: a.elapsed_days, scheduled_days: o, review: r }, u = { card: { ...a, due: r, stability: 0, difficulty: 0, elapsed_days: 0, scheduled_days: 0, reps: s ? 0 : a.reps, lapses: s ? 0 : a.lapses, state: h.New, last_review: a.last_review }, log: c };
+    return n && typeof n == "function" ? n(u) : u;
+  }
+  reschedule(i, r = [], s = {}) {
+    const { recordLogHandler: n, reviewsOrderBy: a, skipManual: o = !0, now: c = /* @__PURE__ */ new Date(), update_memory_state: u = !1 } = s;
+    a && typeof a == "function" && r.sort(a), o && (r = r.filter((ze) => ze.rating !== l.Manual));
+    const f = new Qe(this), y = f.reschedule(s.first_card || P(), r), g = y.length, E = d.card(i), R = f.calculateManualRecord(E, c, g ? y[g - 1] : void 0, u);
+    return n && typeof n == "function" ? { collections: y.map(n), reschedule_item: R ? n(R) : null } : { collections: y, reschedule_item: R };
+  }
+}
+const et = (t) => new Ve(t || {}), tt = W({
+  request_retention: Pe,
+  enable_fuzz: !0,
+  maximum_interval: 100
+}), pe = et(tt), ge = (t) => t.due ? t : { ...t, due: /* @__PURE__ */ new Date() }, it = (t) => fe.indexOf(t), ve = (t) => ({
+  due: t.due,
+  stability: t.stability,
+  difficulty: t.difficulty,
+  elapsed_days: t.elapsedDays,
+  scheduled_days: t.scheduledDays,
+  reps: t.reps,
+  lapses: t.lapses,
+  state: it(t.state),
+  last_review: t.lastReview
+}), rt = (t, e, i) => {
+  const r = /* @__PURE__ */ new Date(), s = ve(ge(t));
+  return pe.repeat(s, r, (a) => {
+    const o = at(e), c = a[o], u = nt(c.card, t), f = c.log, y = {
+      id: 0,
+      // will be set by the database
+      cardReviewId: t.id,
+      grade: e,
+      state: be(f.state),
+      due: f.due,
+      stability: f.stability,
+      difficulty: f.difficulty,
+      elapsedDays: f.elapsed_days,
+      lastElapsedDays: f.last_elapsed_days,
+      scheduledDays: f.scheduled_days,
+      review: f.review,
+      duration: i
+    };
+    return { nextCard: u, reviewLog: y };
+  });
+};
+function At(t) {
+  const e = /* @__PURE__ */ new Date(), i = ve(ge(t)), r = pe.repeat(i, e), s = Object.fromEntries(V.map((n) => [n, /* @__PURE__ */ new Date()]));
+  for (const n of he) {
+    const a = r[n].card.due, o = st(n);
+    s[o] = a;
+  }
+  return s;
+}
+function st(t) {
+  return V[t];
+}
+function be(t) {
+  return fe[t];
+}
+function nt(t, e) {
+  return {
+    ...e,
+    due: t.due,
+    stability: t.stability,
+    difficulty: t.difficulty,
+    elapsedDays: t.elapsed_days,
+    scheduledDays: t.scheduled_days,
+    reps: t.reps,
+    lapses: t.lapses,
+    state: be(t.state),
+    lastReview: t.last_review ?? null
+  };
+}
+function at(t) {
+  const e = V.indexOf(t);
+  if (e === -1)
+    throw new Error(`Invalid rating: ${t}`);
+  return e;
+}
+function Tt(t, e) {
+  const i = P();
+  return {
+    id: "",
+    due: null,
+    stability: i.stability,
+    difficulty: i.difficulty,
+    elapsedDays: i.elapsed_days,
+    scheduledDays: i.scheduled_days,
+    reps: i.reps,
+    lapses: i.lapses,
+    state: Ne.New,
+    lastReview: i.last_review ?? null,
+    userDeckStudyId: t,
+    cardId: e
+  };
+}
+var xe = Symbol.for("immer-nothing"), ne = Symbol.for("immer-draftable"), w = Symbol.for("immer-state"), ot = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(t) {
+    return `The plugin for '${t}' has not been loaded into Immer. To enable the plugin, import and call \`enable${t}()\` when initializing your application.`;
+  },
+  function(t) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${t}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(t) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + t;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(t) {
+    return `'current' expects a draft, got: ${t}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(t) {
+    return `'original' expects a draft, got: ${t}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function m(t, ...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const i = ot[t], r = typeof i == "function" ? i.apply(null, e) : i;
+    throw new Error(`[Immer] ${r}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${t}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var C = Object.getPrototypeOf;
+function S(t) {
+  return !!t && !!t[w];
+}
+function x(t) {
+  var e;
+  return t ? Me(t) || Array.isArray(t) || !!t[ne] || !!((e = t.constructor) != null && e[ne]) || F(t) || H(t) : !1;
+}
+var lt = Object.prototype.constructor.toString(), ae = /* @__PURE__ */ new WeakMap();
+function Me(t) {
+  if (!t || typeof t != "object")
+    return !1;
+  const e = Object.getPrototypeOf(t);
+  if (e === null || e === Object.prototype)
+    return !0;
+  const i = Object.hasOwnProperty.call(e, "constructor") && e.constructor;
+  if (i === Object)
+    return !0;
+  if (typeof i != "function")
+    return !1;
+  let r = ae.get(i);
+  return r === void 0 && (r = Function.toString.call(i), ae.set(i, r)), r === lt;
+}
+function A(t, e, i = !0) {
+  j(t) === 0 ? (i ? Reflect.ownKeys(t) : Object.keys(t)).forEach((s) => {
+    e(s, t[s], t);
+  }) : t.forEach((r, s) => e(s, r, t));
+}
+function j(t) {
+  const e = t[w];
+  return e ? e.type_ : Array.isArray(t) ? 1 : F(t) ? 2 : H(t) ? 3 : 0;
+}
+function K(t, e) {
+  return j(t) === 2 ? t.has(e) : Object.prototype.hasOwnProperty.call(t, e);
+}
+function Se(t, e, i) {
+  const r = j(t);
+  r === 2 ? t.set(e, i) : r === 3 ? t.add(i) : t[e] = i;
+}
+function ct(t, e) {
+  return t === e ? t !== 0 || 1 / t === 1 / e : t !== t && e !== e;
+}
+function F(t) {
+  return t instanceof Map;
+}
+function H(t) {
+  return t instanceof Set;
+}
+function v(t) {
+  return t.copy_ || t.base_;
+}
+function B(t, e) {
+  if (F(t))
+    return new Map(t);
+  if (H(t))
+    return new Set(t);
+  if (Array.isArray(t))
+    return Array.prototype.slice.call(t);
+  const i = Me(t);
+  if (e === !0 || e === "class_only" && !i) {
+    const r = Object.getOwnPropertyDescriptors(t);
+    delete r[w];
+    let s = Reflect.ownKeys(r);
+    for (let n = 0; n < s.length; n++) {
+      const a = s[n], o = r[a];
+      o.writable === !1 && (o.writable = !0, o.configurable = !0), (o.get || o.set) && (r[a] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: o.enumerable,
+        value: t[a]
+      });
+    }
+    return Object.create(C(t), r);
+  } else {
+    const r = C(t);
+    if (r !== null && i)
+      return { ...t };
+    const s = Object.create(r);
+    return Object.assign(s, t);
+  }
+}
+function ee(t, e = !1) {
+  return $(t) || S(t) || !x(t) || (j(t) > 1 && Object.defineProperties(t, {
+    set: I,
+    add: I,
+    clear: I,
+    delete: I
+  }), Object.freeze(t), e && Object.values(t).forEach((i) => ee(i, !0))), t;
+}
+function ut() {
+  m(2);
+}
+var I = {
+  value: ut
+};
+function $(t) {
+  return t === null || typeof t != "object" ? !0 : Object.isFrozen(t);
+}
+var dt = {};
+function M(t) {
+  const e = dt[t];
+  return e || m(0, t), e;
+}
+var z;
+function Ee() {
+  return z;
+}
+function ft(t, e) {
+  return {
+    drafts_: [],
+    parent_: t,
+    immer_: e,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function oe(t, e) {
+  e && (M("Patches"), t.patches_ = [], t.inversePatches_ = [], t.patchListener_ = e);
+}
+function X(t) {
+  Z(t), t.drafts_.forEach(ht), t.drafts_ = null;
+}
+function Z(t) {
+  t === z && (z = t.parent_);
+}
+function le(t) {
+  return z = ft(z, t);
+}
+function ht(t) {
+  const e = t[w];
+  e.type_ === 0 || e.type_ === 1 ? e.revoke_() : e.revoked_ = !0;
+}
+function ce(t, e) {
+  e.unfinalizedDrafts_ = e.drafts_.length;
+  const i = e.drafts_[0];
+  return t !== void 0 && t !== i ? (i[w].modified_ && (X(e), m(4)), x(t) && (t = T(e, t), e.parent_ || k(e, t)), e.patches_ && M("Patches").generateReplacementPatches_(
+    i[w].base_,
+    t,
+    e.patches_,
+    e.inversePatches_
+  )) : t = T(e, i, []), X(e), e.patches_ && e.patchListener_(e.patches_, e.inversePatches_), t !== xe ? t : void 0;
+}
+function T(t, e, i) {
+  if ($(e))
+    return e;
+  const r = t.immer_.shouldUseStrictIteration(), s = e[w];
+  if (!s)
+    return A(
+      e,
+      (n, a) => ue(t, s, e, n, a, i),
+      r
+    ), e;
+  if (s.scope_ !== t)
+    return e;
+  if (!s.modified_)
+    return k(t, s.base_, !0), s.base_;
+  if (!s.finalized_) {
+    s.finalized_ = !0, s.scope_.unfinalizedDrafts_--;
+    const n = s.copy_;
+    let a = n, o = !1;
+    s.type_ === 3 && (a = new Set(n), n.clear(), o = !0), A(
+      a,
+      (c, u) => ue(
+        t,
+        s,
+        n,
+        c,
+        u,
+        i,
+        o
+      ),
+      r
+    ), k(t, n, !1), i && t.patches_ && M("Patches").generatePatches_(
+      s,
+      i,
+      t.patches_,
+      t.inversePatches_
+    );
+  }
+  return s.copy_;
+}
+function ue(t, e, i, r, s, n, a) {
+  if (s == null || typeof s != "object" && !a)
+    return;
+  const o = $(s);
+  if (!(o && !a)) {
+    if (process.env.NODE_ENV !== "production" && s === i && m(5), S(s)) {
+      const c = n && e && e.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !K(e.assigned_, r) ? n.concat(r) : void 0, u = T(t, s, c);
+      if (Se(i, r, u), S(u))
+        t.canAutoFreeze_ = !1;
+      else
+        return;
+    } else a && i.add(s);
+    if (x(s) && !o) {
+      if (!t.immer_.autoFreeze_ && t.unfinalizedDrafts_ < 1 || e && e.base_ && e.base_[r] === s && o)
+        return;
+      T(t, s), (!e || !e.scope_.parent_) && typeof r != "symbol" && (F(i) ? i.has(r) : Object.prototype.propertyIsEnumerable.call(i, r)) && k(t, s);
+    }
+  }
+}
+function k(t, e, i = !1) {
+  !t.parent_ && t.immer_.autoFreeze_ && t.canAutoFreeze_ && ee(e, i);
+}
+function _t(t, e) {
+  const i = Array.isArray(t), r = {
+    type_: i ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: e ? e.scope_ : Ee(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: e,
+    // The base state.
+    base_: t,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let s = r, n = te;
+  i && (s = [r], n = O);
+  const { revoke: a, proxy: o } = Proxy.revocable(s, n);
+  return r.draft_ = o, r.revoke_ = a, o;
+}
+var te = {
+  get(t, e) {
+    if (e === w)
+      return t;
+    const i = v(t);
+    if (!K(i, e))
+      return yt(t, i, e);
+    const r = i[e];
+    return t.finalized_ || !x(r) ? r : r === U(t.base_, e) ? (q(t), t.copy_[e] = Q(r, t)) : r;
+  },
+  has(t, e) {
+    return e in v(t);
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(v(t));
+  },
+  set(t, e, i) {
+    const r = Re(v(t), e);
+    if (r != null && r.set)
+      return r.set.call(t.draft_, i), !0;
+    if (!t.modified_) {
+      const s = U(v(t), e), n = s == null ? void 0 : s[w];
+      if (n && n.base_ === i)
+        return t.copy_[e] = i, t.assigned_[e] = !1, !0;
+      if (ct(i, s) && (i !== void 0 || K(t.base_, e)))
+        return !0;
+      q(t), J(t);
+    }
+    return t.copy_[e] === i && // special case: handle new props with value 'undefined'
+    (i !== void 0 || e in t.copy_) || // special case: NaN
+    Number.isNaN(i) && Number.isNaN(t.copy_[e]) || (t.copy_[e] = i, t.assigned_[e] = !0), !0;
+  },
+  deleteProperty(t, e) {
+    return U(t.base_, e) !== void 0 || e in t.base_ ? (t.assigned_[e] = !1, q(t), J(t)) : delete t.assigned_[e], t.copy_ && delete t.copy_[e], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(t, e) {
+    const i = v(t), r = Reflect.getOwnPropertyDescriptor(i, e);
+    return r && {
+      writable: !0,
+      configurable: t.type_ !== 1 || e !== "length",
+      enumerable: r.enumerable,
+      value: i[e]
+    };
+  },
+  defineProperty() {
+    m(11);
+  },
+  getPrototypeOf(t) {
+    return C(t.base_);
+  },
+  setPrototypeOf() {
+    m(12);
+  }
+}, O = {};
+A(te, (t, e) => {
+  O[t] = function() {
+    return arguments[0] = arguments[0][0], e.apply(this, arguments);
+  };
+});
+O.deleteProperty = function(t, e) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(e)) && m(13), O.set.call(this, t, e, void 0);
+};
+O.set = function(t, e, i) {
+  return process.env.NODE_ENV !== "production" && e !== "length" && isNaN(parseInt(e)) && m(14), te.set.call(this, t[0], e, i, t[0]);
+};
+function U(t, e) {
+  const i = t[w];
+  return (i ? v(i) : t)[e];
+}
+function yt(t, e, i) {
+  var s;
+  const r = Re(e, i);
+  return r ? "value" in r ? r.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (s = r.get) == null ? void 0 : s.call(t.draft_)
+  ) : void 0;
+}
+function Re(t, e) {
+  if (!(e in t))
+    return;
+  let i = C(t);
+  for (; i; ) {
+    const r = Object.getOwnPropertyDescriptor(i, e);
+    if (r)
+      return r;
+    i = C(i);
+  }
+}
+function J(t) {
+  t.modified_ || (t.modified_ = !0, t.parent_ && J(t.parent_));
+}
+function q(t) {
+  t.copy_ || (t.copy_ = B(
+    t.base_,
+    t.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var mt = class {
+  constructor(t) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (e, i, r) => {
+      if (typeof e == "function" && typeof i != "function") {
+        const n = i;
+        i = e;
+        const a = this;
+        return function(c = n, ...u) {
+          return a.produce(c, (f) => i.call(this, f, ...u));
+        };
+      }
+      typeof i != "function" && m(6), r !== void 0 && typeof r != "function" && m(7);
+      let s;
+      if (x(e)) {
+        const n = le(this), a = Q(e, void 0);
+        let o = !0;
+        try {
+          s = i(a), o = !1;
+        } finally {
+          o ? X(n) : Z(n);
+        }
+        return oe(n, r), ce(s, n);
+      } else if (!e || typeof e != "object") {
+        if (s = i(e), s === void 0 && (s = e), s === xe && (s = void 0), this.autoFreeze_ && ee(s, !0), r) {
+          const n = [], a = [];
+          M("Patches").generateReplacementPatches_(e, s, n, a), r(n, a);
+        }
+        return s;
+      } else
+        m(1, e);
+    }, this.produceWithPatches = (e, i) => {
+      if (typeof e == "function")
+        return (a, ...o) => this.produceWithPatches(a, (c) => e(c, ...o));
+      let r, s;
+      return [this.produce(e, i, (a, o) => {
+        r = a, s = o;
+      }), r, s];
+    }, typeof (t == null ? void 0 : t.autoFreeze) == "boolean" && this.setAutoFreeze(t.autoFreeze), typeof (t == null ? void 0 : t.useStrictShallowCopy) == "boolean" && this.setUseStrictShallowCopy(t.useStrictShallowCopy), typeof (t == null ? void 0 : t.useStrictIteration) == "boolean" && this.setUseStrictIteration(t.useStrictIteration);
+  }
+  createDraft(t) {
+    x(t) || m(8), S(t) && (t = wt(t));
+    const e = le(this), i = Q(t, void 0);
+    return i[w].isManual_ = !0, Z(e), i;
+  }
+  finishDraft(t, e) {
+    const i = t && t[w];
+    (!i || !i.isManual_) && m(9);
+    const { scope_: r } = i;
+    return oe(r, e), ce(void 0, r);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(t) {
+    this.autoFreeze_ = t;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(t) {
+    this.useStrictShallowCopy_ = t;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(t) {
+    this.useStrictIteration_ = t;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(t, e) {
+    let i;
+    for (i = e.length - 1; i >= 0; i--) {
+      const s = e[i];
+      if (s.path.length === 0 && s.op === "replace") {
+        t = s.value;
+        break;
+      }
+    }
+    i > -1 && (e = e.slice(i + 1));
+    const r = M("Patches").applyPatches_;
+    return S(t) ? r(t, e) : this.produce(
+      t,
+      (s) => r(s, e)
+    );
+  }
+};
+function Q(t, e) {
+  const i = F(t) ? M("MapSet").proxyMap_(t, e) : H(t) ? M("MapSet").proxySet_(t, e) : _t(t, e);
+  return (e ? e.scope_ : Ee()).drafts_.push(i), i;
+}
+function wt(t) {
+  return S(t) || m(10, t), De(t);
+}
+function De(t) {
+  if (!x(t) || $(t))
+    return t;
+  const e = t[w];
+  let i, r = !0;
+  if (e) {
+    if (!e.modified_)
+      return e.base_;
+    e.finalized_ = !0, i = B(t, e.scope_.immer_.useStrictShallowCopy_), r = e.scope_.immer_.shouldUseStrictIteration();
+  } else
+    i = B(t, !0);
+  return A(
+    i,
+    (s, n) => {
+      Se(i, s, De(n));
+    },
+    r
+  ), e && (e.finalized_ = !1), i;
+}
+var pt = new mt(), gt = pt.produce;
+function vt(t, e) {
+  const i = t + e;
+  let r = 0;
+  for (let s = 0; s < i.length; s++) {
+    const n = i.charCodeAt(s);
+    r = (r << 5) - r + n, r |= 0;
+  }
+  return r;
+}
+function bt(t, e) {
+  return (vt(t, e) >>> 0) / 4294967295;
+}
+function kt(t, e = /* @__PURE__ */ new Set()) {
+  if (t.reviewCards.length === 0 && t.newCards.length === 0)
+    return;
+  if (t.reviewCards.length === 0)
+    return t.newCards[0];
+  if (t.newCards.length === 0)
+    return t.reviewCards[0];
+  const i = de(t.newCards, e), r = de(t.reviewCards, e);
+  if (!i) return r ?? t.newCards[0];
+  if (!r) return i ?? t.reviewCards[0];
+  const s = t.newCards.length, n = t.reviewCards.length, a = s + n, o = 0.33, c = s / a, u = (o + c) / 2;
+  return bt(i.card.id, r.card.id) < u ? i : r;
+}
+function de(t, e) {
+  return t.find((i) => !e.has(i.card.id));
+}
+function jt(t, e, i) {
+  const r = St(e, i);
+  if (!r)
+    return e;
+  const { nextCard: s } = rt(r.cardReview, t, 30), n = s.due && Ie(s.due, /* @__PURE__ */ new Date());
+  return gt(e, (a) => {
+    if (xt(a, r), n) {
+      const o = {
+        ...r,
+        cardReview: s
+      };
+      Mt(a, o);
+    }
+  });
+}
+function xt(t, e) {
+  e.cardReview.state === "New" ? t.newCards = t.newCards.filter((i) => i.card.id !== e.card.id) : t.reviewCards = t.reviewCards.filter((i) => i.card.id !== e.card.id), Ce(t, e.cardReview.state, "decrease");
+}
+function Mt(t, e) {
+  if (e.cardReview.state === "New") {
+    const i = t.newCards.findIndex(
+      (r) => r.cardReview.due && e.cardReview.due && r.cardReview.due >= e.cardReview.due || r.cardReview.difficulty >= e.cardReview.difficulty
+    );
+    i === -1 ? t.newCards.push(e) : t.newCards.splice(i, 0, e);
+  } else {
+    const i = Et(t, t.reviewCards);
+    t.reviewCards.splice(i, 0, e);
+  }
+  Ce(t, e.cardReview.state, "increase");
+}
+function Ce(t, e, i) {
+  const r = i === "increase" ? 1 : -1;
+  switch (e) {
+    case "New":
+      t.stats.new += r;
+      break;
+    case "Learning":
+    case "Relearning":
+      t.stats.learning += r;
+      break;
+    case "Review":
+      t.stats.review += r;
+      break;
+    default:
+      t.stats.new += r;
+      break;
+  }
+  t.stats.total += r;
+}
+function St(t, e) {
+  return t.newCards.find((i) => i.card.id === e) ?? t.reviewCards.find((i) => i.card.id === e);
+}
+function Et(t, e) {
+  if (e.length === 0)
+    return 0;
+  const i = Math.max(4, Math.floor(e.length / 3));
+  return Math.min(i, e.length);
+}
+export {
+  Pe as FSRS_RETENTION,
+  Ft as MAX_CARDS_TO_FETCH,
+  Nt as MAX_LEARN_PER_DAY,
+  It as MAX_NEW_PER_DECK_DAY,
+  Pt as THRESHOLD_CARDS_FOR_REFETCH,
+  kt as getNextCardFromSession,
+  At as getReviewDateForEachRating,
+  St as getSessionCard,
+  rt as gradeCard,
+  nt as mergeFsrsCard,
+  Tt as newCardReview,
+  jt as removeCardFromSessionData
+};