Implementing singleton with vanilla JavaScript in frontend

I have a project ( vanilla web application ) where I serve html files from the backend using nodejs router:

router.get("/", (req, res) => {
    res.sendFile(views_dir + "index.html");
});

router.get("/login", (req, res) => {
    res.sendFile(views_dir + "login.html");
});

and serve the js files as static app.use(express.static(path.join(__dirname, '/frontend'))); where the /frontend folder holds all the frontend files ( including the html files ).

Now, I have a file called model.js ( in frontend folder ) where I'm trying to implement a singleton that will hold data that is common to all pages ( such as if the user is currently logged or not ):

const Model = (function () {
    let instance;

    function init() { 

        let isLogged = false;

        return {
            getIsLogged: function () {
                return isLogged;
            },
            setIsLogged: function (l) {
                isLogged = l;
            }
        }
    }
    return { 
        getInstance: function () {
            if (! instance) {
                instance = init();
            }
            return instance;
        }
    }
})();

But when a user being redirected, seems like the model.js being imported all over again from the backend side, overriding all changes to the model from the previous page.
( Say we change the isLogged variable in the model to true when a user logged in, and redirecting to '/', the model being refreshed and overwritten )

Is there even a way to implement such a requirement with just JavaScript ?

I think the problem is with res.sendFile(views_dir + "index.html"); which refreshes the application to a new state and doesn't saves the previous state of the js files, is there a way to avoid this ? to request the js files just once ?

Figured it out thanks to @Jared

I used localStorage to save the model's current state and load it back when redirecting to another page.

const Model = (function () {

    let instance;

    let data = {
        isLogged: false,
    };

    function init_localStorage() {
        save_localStorage();
    }

    function load_localStorage() {
        let model = JSON.parse(localStorage.getItem('Model'));
        if (Object.keys(model).length === 0) {
            init_localStorage();
        }

        data = model;
    }

    function save_localStorage() {
        localStorage.setItem('Model', JSON.stringify(data));
    }

    function init() {
        load_localStorage();

        return {
            getIsLogged: function () {
                return data.isLogged;
            },
            setIsLogged: function (l) {
                data.isLogged = l;
            },

            saveData: function () {
                save_localStorage();
            }
        }
    }

    return {
        getInstance: function () {
            if (! instance) {
                instance = init();
            }
            return instance;
        }
    }
})();

Eventually, I have two main function: save... and load... which reads\saves from the localStorage object.
As Jared stated in the comments, JSON cannot stringify a function, thus I created an object called data where I store all the model's data ( for example isLogged variable ).

Now, whenever I want to access the model's data, I get its instance first: let model = Model.getInstance();
and then I can access the methods from the init function that I'm returning.
When I request the Model instance, it first checks if the current instance is not yet initialized. If not, it calls the load_localStorage which reads localStorage and saves it to data variable.

Before I redirect to another page I call saveData of Model's instance to save the data object to localStorage, so the page redirected to can read the previous saved state.

In HTML files, I included the js files like this: <script src="./../model/model.js"></script>.

I'm sure there is a better solution to the problem, and maybe a more readable code, but this got me working just fine

Edit:

It is important to note that sessionStorage might be a better solution than localStorage as localStorage doesn't doesn't expire, meaning if you save things you want to be refreshed \ wiped out when the server is refreshed\updated, it will still load old data from localStorage as nothing changed.

For example, I saved some common HTML part in the model in localStorage, and each time I ran npm start it didn't show the changes I made to it, as I'm loading the HTML part from localStorage and not again from the server.