ts-fsrs 2.2.0 → 3.0.0

package/dist/default.d.ts

@@ -3,16 +3,12 @@ import { EnvParams } from "./type";
 export declare const envParams: EnvParams;
 export declare const default_request_retention: number;
 export declare const default_maximum_interval: number;
-export declare const default_easy_bonus: number;
-export declare const default_hard_factor: number;
 export declare const default_w: number[];
 export declare const default_enable_fuzz: boolean;
 export declare const FSRSVersion: string;
 export declare const generatorParameters: (props?: Partial<FSRSParameters>) => {
     request_retention: number;
     maximum_interval: number;
-    easy_bonus: number;
-    hard_factor: number;
     w: number[];
     enable_fuzz: boolean;
 };

package/dist/default.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.envParams = void 0;
+exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_maximum_interval = exports.default_request_retention = exports.envParams = void 0;
 const index_1 = require("./index");
 const dotenv_1 = __importDefault(require("dotenv"));
 dotenv_1.default.config({ path: `./.env.local` });
@@ -13,8 +13,6 @@ dotenv_1.default.config({ path: `./.env.development` });
 exports.envParams = {
     FSRS_REQUEST_RETENTION: Number(process.env.FSRS_REQUEST_RETENTION),
     FSRS_MAXIMUM_INTERVAL: Number(process.env.FSRS_MAXIMUM_INTERVAL),
-    FSRS_EASY_BOUND: Number(process.env.FSRS_EASY_BOUND),
-    FSRS_HARD_FACTOR: Number(process.env.FSRS_HARD_FACTOR),
     FSRS_W: process.env.FSRS_W
         ? JSON.parse(process.env.FSRS_W)
         : undefined,
@@ -26,23 +24,16 @@ exports.default_request_retention = !isNaN(exports.envParams.FSRS_REQUEST_RETENT
 exports.default_maximum_interval = !isNaN(exports.envParams.FSRS_MAXIMUM_INTERVAL)
     ? exports.envParams.FSRS_MAXIMUM_INTERVAL
     : 36500;
-exports.default_easy_bonus = !isNaN(exports.envParams.FSRS_EASY_BOUND)
-    ? exports.envParams.FSRS_EASY_BOUND
-    : 1.3;
-exports.default_hard_factor = !isNaN(exports.envParams.FSRS_HARD_FACTOR)
-    ? exports.envParams.FSRS_HARD_FACTOR
-    : 1.2;
 exports.default_w = exports.envParams.FSRS_W || [
-    1, 1, 5, -0.5, -0.5, 0.2, 1.4, -0.12, 0.8, 2, -0.2, 0.2, 1,
+    0.4, 0.6, 2.4, 5.8, 4.93, 0.94, 0.86, 0.01, 1.49, 0.14, 0.94, 2.18, 0.05,
+    0.34, 1.26, 0.29, 2.61,
 ];
 exports.default_enable_fuzz = exports.envParams.FSRS_ENABLE_FUZZ || false;
-exports.FSRSVersion = "2.2.0";
+exports.FSRSVersion = "3.0.0";
 const generatorParameters = (props) => {
     return {
         request_retention: props?.request_retention || exports.default_request_retention,
         maximum_interval: props?.maximum_interval || exports.default_maximum_interval,
-        easy_bonus: props?.easy_bonus || exports.default_easy_bonus,
-        hard_factor: props?.hard_factor || exports.default_hard_factor,
         w: props?.w || exports.default_w,
         enable_fuzz: props?.enable_fuzz || exports.default_enable_fuzz,
     };

package/dist/fsrs.d.ts

@@ -7,7 +7,7 @@ export declare class FSRS {
     private seed?;
     constructor(param: Partial<FSRSParameters>);
     repeat: (card: Card, now: Date) => {
-        0: {
+        1: {
             card: Card;
             log: {
                 rating: Rating;
@@ -17,7 +17,7 @@ export declare class FSRS {
                 review: Date;
             };
         };
-        1: {
+        2: {
             card: Card;
             log: {
                 rating: Rating;
@@ -27,7 +27,7 @@ export declare class FSRS {
                 review: Date;
             };
         };
-        2: {
+        3: {
             card: Card;
             log: {
                 rating: Rating;
@@ -37,7 +37,7 @@ export declare class FSRS {
                 review: Date;
             };
         };
-        3: {
+        4: {
             card: Card;
             log: {
                 rating: Rating;
@@ -60,28 +60,34 @@ export declare class FSRS {
     next_ds(s: SchedulingCard, last_d: number, last_s: number, retrievability: number): void;
     /**
      * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$S_0(G) = w_{G-1}$$
      * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return Stability (interval when R=90%)
      */
     init_stability(g: number): number;
     /**
      * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$D_0(G) = w_4 - (G-3) \cdot w_5$$
      * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * where the D_0(3)=w_4 when the first rating is good.
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return Difficulty D \in [1,10]
      */
     init_difficulty(g: number): number;
     apply_fuzz(ivl: number): number;
+    /**
+     *  Ref:
+     *   constructor(param: Partial<FSRSParameters>)
+     *   this.intervalModifier = 9 * (1 / this.param.request_retention - 1);
+     */
     next_interval(s: number): int;
     /**
      * The formula used is :
-     * $$next_d = D + w_4 \cdot (R - 2)$$
+     * $$next_d = D - w_6 \cdot (R - 2)$$
      * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
      * @param d
-     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return next_D
      */
     next_difficulty(d: number, g: number): number;
@@ -92,24 +98,25 @@ export declare class FSRS {
     constrain_difficulty(difficulty: number): number;
     /**
      * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
+     * $$w_7 \cdot init +(1 - w_7) \cdot current$$
+     * @param init $$w_2 : D_0(3) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D - w_6 \cdot (R - 2)$$
      * @return difficulty
      */
     mean_reversion(init: number, current: number): number;
     /**
      * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * $$S^\prime_r(D,S,R,G) = S\cdot(e^{w_8}\cdot (11-D)\cdot S^{-w_9}\cdot(e^{w_10\cdot(1-R)}-1)\cdot w_15(if G=2) \cdot w_16(if G=4)+1)$$
      * @param d Difficulty D \in [1,10]
      * @param s Stability (interval when R=90%)
      * @param r Retrievability (probability of recall)
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
      * @return S^\prime_r new stability after recall
      */
-    next_recall_stability(d: number, s: number, r: number): number;
+    next_recall_stability(d: number, s: number, r: number, g: Rating): number;
     /**
      * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
+     * $$S^\prime_f(D,S,R) = w_11\cdot D^{-w_{12}}\cdot ((S+1)^{w_{13}}-1) \cdot e^{w_{14}\cdot(1-R)}.$$
      * @param d Difficulty D \in [1,10]
      * @param s Stability (interval when R=90%)
      * @param r Retrievability (probability of recall)
@@ -118,7 +125,7 @@ export declare class FSRS {
     next_forget_stability(d: number, s: number, r: number): number;
     /**
      * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * $$R(t,S) = (1 + \frac{t}{9 \cdot S})^{-1},$$
      * @param t t days since the last review
      * @param s Stability (interval when R=90%)
      * @return r Retrievability (probability of recall)

package/dist/fsrs.js

@@ -8,14 +8,16 @@ const seedrandom_1 = __importDefault(require("seedrandom"));
 const index_1 = require("./index");
 const help_1 = require("./help");
 const models_1 = require("./models");
+// Ref: https://github.com/open-spaced-repetition/fsrs4anki/wiki/The-Algorithm#fsrs-v4
 class FSRS {
     param;
     intervalModifier;
     seed;
     constructor(param) {
         this.param = (0, index_1.generatorParameters)(param);
-        this.intervalModifier =
-            Math.log(this.param.request_retention) / Math.log(0.9);
+        // Ref: https://github.com/open-spaced-repetition/py-fsrs/blob/ecd68e453611eb808c7367c7a5312d7cadeedf5c/src/fsrs/fsrs.py#L79
+        // The formula used is : I(r,s)=9 \cdot  s \cdot (\frac{1}{r}-1)
+        this.intervalModifier = 9 * (1 / this.param.request_retention - 1);
     }
     repeat = (card, now) => {
         card = {
@@ -37,7 +39,7 @@ class FSRS {
                 s.again.due = now.scheduler(1);
                 s.hard.due = now.scheduler(5);
                 s.good.due = now.scheduler(10);
-                easy_interval = this.next_interval(s.easy.stability * this.param.easy_bonus);
+                easy_interval = this.next_interval(s.easy.stability);
                 s.easy.scheduled_days = easy_interval;
                 s.easy.due = now.scheduler(easy_interval, true);
                 break;
@@ -45,7 +47,7 @@ class FSRS {
             case models_1.State.Relearning:
                 hard_interval = 0;
                 good_interval = this.next_interval(s.good.stability);
-                easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                easy_interval = Math.max(this.next_interval(s.easy.stability), good_interval + 1);
                 s.schedule(now, hard_interval, good_interval, easy_interval);
                 break;
             case models_1.State.Review: {
@@ -54,11 +56,11 @@ class FSRS {
                 const last_s = card.stability;
                 const retrievability = this.current_retrievability(interval, last_s);
                 this.next_ds(s, last_d, last_s, retrievability);
-                hard_interval = this.next_interval(last_s * this.param.hard_factor);
+                hard_interval = this.next_interval(s.hard.stability);
                 good_interval = this.next_interval(s.good.stability);
                 hard_interval = Math.min(hard_interval, good_interval);
                 good_interval = Math.max(good_interval, hard_interval + 1);
-                easy_interval = Math.max(this.next_interval(s.easy.stability * this.param.easy_bonus), good_interval + 1);
+                easy_interval = Math.max(this.next_interval(s.easy.stability), good_interval + 1);
                 s.schedule(now, hard_interval, good_interval, easy_interval);
                 break;
             }
@@ -93,31 +95,32 @@ class FSRS {
         s.again.difficulty = this.next_difficulty(last_d, models_1.Rating.Again);
         s.again.stability = this.next_forget_stability(s.again.difficulty, last_s, retrievability);
         s.hard.difficulty = this.next_difficulty(last_d, models_1.Rating.Hard);
-        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability);
+        s.hard.stability = this.next_recall_stability(s.hard.difficulty, last_s, retrievability, models_1.Rating.Hard);
         s.good.difficulty = this.next_difficulty(last_d, models_1.Rating.Good);
-        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability);
+        s.good.stability = this.next_recall_stability(s.good.difficulty, last_s, retrievability, models_1.Rating.Good);
         s.easy.difficulty = this.next_difficulty(last_d, models_1.Rating.Easy);
-        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability);
+        s.easy.stability = this.next_recall_stability(s.easy.difficulty, last_s, retrievability, models_1.Rating.Easy);
     }
     /**
      * The formula used is :
-     * $$S_0(G) = w_0 + G \cdot w_1$$
+     * $$S_0(G) = w_{G-1}$$
      * $$\max \{S_0,0.1\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return Stability (interval when R=90%)
      */
     init_stability(g) {
-        return Math.max(this.param.w[0] + this.param.w[1] * g, 0.1);
+        return Math.max(this.param.w[g - 1], 0.1);
     }
     /**
      * The formula used is :
-     * $$D_0(G) = w_2 + (G-2) \cdot w_3$$
+     * $$D_0(G) = w_4 - (G-3) \cdot w_5$$
      * $$\min \{\max \{D_0(G),1\},10\}$$
-     * @param g Grade (rating at Anki) [0.again,1.hard,2.good,3.easy]
+     * where the D_0(3)=w_4 when the first rating is good.
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return Difficulty D \in [1,10]
      */
     init_difficulty(g) {
-        return Math.min(Math.max(this.param.w[2] + this.param.w[3] * (g - 2), 1), 10);
+        return Math.min(Math.max(this.param.w[4] - (g - 3) * this.param.w[5], 1), 10);
     }
     apply_fuzz(ivl) {
         if (!this.param.enable_fuzz || ivl < 2.5)
@@ -129,21 +132,26 @@ class FSRS {
         const max_ivl = Math.round(ivl * 1.05 + 1);
         return Math.floor(fuzz_factor * (max_ivl - min_ivl + 1) + min_ivl);
     }
+    /**
+     *  Ref:
+     *   constructor(param: Partial<FSRSParameters>)
+     *   this.intervalModifier = 9 * (1 / this.param.request_retention - 1);
+     */
     next_interval(s) {
         const newInterval = this.apply_fuzz(s * this.intervalModifier);
         return Math.min(Math.max(Math.round(newInterval), 1), this.param.maximum_interval);
     }
     /**
      * The formula used is :
-     * $$next_d = D + w_4 \cdot (R - 2)$$
+     * $$next_d = D - w_6 \cdot (R - 2)$$
      * $$D^\prime(D,R) = w_5 \cdot D_0(2) +(1 - w_5) \cdot next_d$$
      * @param d
-     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
+     * @param g Grade (rating at Anki) [1.again,2.hard,3.good,4.easy]
      * @return next_D
      */
     next_difficulty(d, g) {
-        const next_d = d + this.param.w[4] * (g - 2);
-        return this.constrain_difficulty(this.mean_reversion(this.param.w[2], next_d));
+        const next_d = d - this.param.w[6] * (g - 3);
+        return this.constrain_difficulty(this.mean_reversion(this.param.w[4], next_d));
     }
     /**
      * The formula used is :
@@ -154,53 +162,58 @@ class FSRS {
     }
     /**
      * The formula used is :
-     * $$w_5 \cdot init +(1 - w_5) \cdot current$$
-     * @param init $$w_2 : D_0(2) = w_2 + (R-2) \cdot w_3= w_2$$
-     * @param current $$D + w_4 \cdot (R - 2)$$
+     * $$w_7 \cdot init +(1 - w_7) \cdot current$$
+     * @param init $$w_2 : D_0(3) = w_2 + (R-2) \cdot w_3= w_2$$
+     * @param current $$D - w_6 \cdot (R - 2)$$
      * @return difficulty
      */
     mean_reversion(init, current) {
-        return this.param.w[5] * init + (1 - this.param.w[5]) * current;
+        return this.param.w[7] * init + (1 - this.param.w[7]) * current;
     }
     /**
      * The formula used is :
-     * $$S^\prime_r(D,S,R) = S\cdot(e^{w_6}\cdot (11-D)\cdot S^{w_7}\cdot(e^{w_8\cdot(1-R)}-1)+1)$$
+     * $$S^\prime_r(D,S,R,G) = S\cdot(e^{w_8}\cdot (11-D)\cdot S^{-w_9}\cdot(e^{w_10\cdot(1-R)}-1)\cdot w_15(if G=2) \cdot w_16(if G=4)+1)$$
      * @param d Difficulty D \in [1,10]
      * @param s Stability (interval when R=90%)
      * @param r Retrievability (probability of recall)
+     * @param g Grade (Rating[0.again,1.hard,2.good,3.easy])
      * @return S^\prime_r new stability after recall
      */
-    next_recall_stability(d, s, r) {
+    next_recall_stability(d, s, r, g) {
+        const hard_penalty = models_1.Rating.Hard === g ? this.param.w[15] : 1;
+        const easy_bound = models_1.Rating.Easy === g ? this.param.w[16] : 1;
         return (s *
             (1 +
-                Math.exp(this.param.w[6]) *
+                Math.exp(this.param.w[8]) *
                     (11 - d) *
-                    Math.pow(s, this.param.w[7]) *
-                    (Math.exp((1 - r) * this.param.w[8]) - 1)));
+                    Math.pow(s, -this.param.w[9]) *
+                    (Math.exp((1 - r) * this.param.w[10]) - 1) *
+                    hard_penalty *
+                    easy_bound));
     }
     /**
      * The formula used is :
-     * $$S^\prime_f(D,S,R) = w_9\cdot D^{w_{10}}\cdot S^{w_{11}}\cdot e^{w_{12}\cdot(1-R)}.$$
+     * $$S^\prime_f(D,S,R) = w_11\cdot D^{-w_{12}}\cdot ((S+1)^{w_{13}}-1) \cdot e^{w_{14}\cdot(1-R)}.$$
      * @param d Difficulty D \in [1,10]
      * @param s Stability (interval when R=90%)
      * @param r Retrievability (probability of recall)
      * @return S^\prime_f new stability after forgetting
      */
     next_forget_stability(d, s, r) {
-        return (this.param.w[9] *
-            Math.pow(d, this.param.w[10]) *
-            Math.pow(s, this.param.w[11]) *
-            Math.exp((1 - r) * this.param.w[12]));
+        return (this.param.w[11] *
+            Math.pow(d, -this.param.w[12]) *
+            (Math.pow(s + 1, this.param.w[13]) - 1) *
+            Math.exp((1 - r) * this.param.w[14]));
     }
     /**
      * The formula used is :
-     * $$R(t,S) = 0.9^{\frac{t}{S}}$$
+     * $$R(t,S) = (1 + \frac{t}{9 \cdot S})^{-1},$$
      * @param t t days since the last review
      * @param s Stability (interval when R=90%)
      * @return r Retrievability (probability of recall)
      */
     current_retrievability(t, s) {
-        return Math.exp((Math.log(0.9) * t) / s);
+        return Math.pow(1 + t / (9 * s), -1);
     }
 }
 exports.FSRS = FSRS;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { SchedulingCard } from "./scheduler";
-export { default_request_retention, default_maximum_interval, default_easy_bonus, default_hard_factor, default_w, default_enable_fuzz, FSRSVersion, generatorParameters, createEmptyCard, fsrs, envParams } from "./default";
+export { default_request_retention, default_maximum_interval, default_w, default_enable_fuzz, FSRSVersion, generatorParameters, createEmptyCard, fsrs, envParams } from "./default";
 export { date_scheduler, date_diff, formatDate, show_diff_message, } from "./help";
 export type { int, double } from "./type";
 export type { FSRSParameters, Card, ReviewLog, StateType, RatingType, } from "./models";

package/dist/index.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FSRS = exports.Rating = exports.State = exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = exports.envParams = exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_hard_factor = exports.default_easy_bonus = exports.default_maximum_interval = exports.default_request_retention = exports.SchedulingCard = void 0;
+exports.FSRS = exports.Rating = exports.State = exports.show_diff_message = exports.formatDate = exports.date_diff = exports.date_scheduler = exports.envParams = exports.fsrs = exports.createEmptyCard = exports.generatorParameters = exports.FSRSVersion = exports.default_enable_fuzz = exports.default_w = exports.default_maximum_interval = exports.default_request_retention = exports.SchedulingCard = void 0;
 var scheduler_1 = require("./scheduler");
 Object.defineProperty(exports, "SchedulingCard", { enumerable: true, get: function () { return scheduler_1.SchedulingCard; } });
 var default_1 = require("./default");
 Object.defineProperty(exports, "default_request_retention", { enumerable: true, get: function () { return default_1.default_request_retention; } });
 Object.defineProperty(exports, "default_maximum_interval", { enumerable: true, get: function () { return default_1.default_maximum_interval; } });
-Object.defineProperty(exports, "default_easy_bonus", { enumerable: true, get: function () { return default_1.default_easy_bonus; } });
-Object.defineProperty(exports, "default_hard_factor", { enumerable: true, get: function () { return default_1.default_hard_factor; } });
 Object.defineProperty(exports, "default_w", { enumerable: true, get: function () { return default_1.default_w; } });
 Object.defineProperty(exports, "default_enable_fuzz", { enumerable: true, get: function () { return default_1.default_enable_fuzz; } });
 Object.defineProperty(exports, "FSRSVersion", { enumerable: true, get: function () { return default_1.FSRSVersion; } });

package/dist/models.d.ts

@@ -1,4 +1,4 @@
-export type StateType = "Learning" | "New" | "Review" | "Relearning";
+export type StateType = "New" | "Learning" | "Review" | "Relearning";
 export declare enum State {
     New = 0,
     Learning = 1,
@@ -7,10 +7,10 @@ export declare enum State {
 }
 export type RatingType = "Again" | "Hard" | "Good" | "Easy";
 export declare enum Rating {
-    Again = 0,
-    Hard = 1,
-    Good = 2,
-    Easy = 3
+    Again = 1,
+    Hard = 2,
+    Good = 3,
+    Easy = 4
 }
 export interface ReviewLog {
     rating: Rating;
@@ -33,8 +33,6 @@ export interface Card {
 export interface FSRSParameters {
     request_retention: number;
     maximum_interval: number;
-    easy_bonus: number;
-    hard_factor: number;
     w: number[];
     enable_fuzz: boolean;
 }

package/dist/models.js

@@ -10,8 +10,8 @@ var State;
 })(State || (exports.State = State = {}));
 var Rating;
 (function (Rating) {
-    Rating[Rating["Again"] = 0] = "Again";
-    Rating[Rating["Hard"] = 1] = "Hard";
-    Rating[Rating["Good"] = 2] = "Good";
-    Rating[Rating["Easy"] = 3] = "Easy";
+    Rating[Rating["Again"] = 1] = "Again";
+    Rating[Rating["Hard"] = 2] = "Hard";
+    Rating[Rating["Good"] = 3] = "Good";
+    Rating[Rating["Easy"] = 4] = "Easy";
 })(Rating || (exports.Rating = Rating = {}));

package/dist/scheduler.d.ts

@@ -9,7 +9,7 @@ export declare class SchedulingCard {
     update_state(state: State): this;
     schedule(now: Date, hard_interval: number, good_interval: number, easy_interval: number): SchedulingCard;
     record_log(card: Card, now: Date): {
-        0: {
+        1: {
             card: Card;
             log: {
                 rating: Rating;
@@ -19,7 +19,7 @@ export declare class SchedulingCard {
                 review: Date;
             };
         };
-        1: {
+        2: {
             card: Card;
             log: {
                 rating: Rating;
@@ -29,7 +29,7 @@ export declare class SchedulingCard {
                 review: Date;
             };
         };
-        2: {
+        3: {
             card: Card;
             log: {
                 rating: Rating;
@@ -39,7 +39,7 @@ export declare class SchedulingCard {
                 review: Date;
             };
         };
-        3: {
+        4: {
             card: Card;
             log: {
                 rating: Rating;

package/dist/type.d.ts

@@ -8,8 +8,6 @@ export type double = number & {
 export interface EnvParams {
     FSRS_REQUEST_RETENTION: number;
     FSRS_MAXIMUM_INTERVAL: number;
-    FSRS_EASY_BOUND: number;
-    FSRS_HARD_FACTOR: number;
     FSRS_W?: number[];
     FSRS_ENABLE_FUZZ?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fsrs",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "description": "ts-fsrs is a TypeScript package used to implement the Free Spaced Repetition Scheduler (FSRS) algorithm. It helps developers apply FSRS to their flashcard applications, thereby improving the user learning experience.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",