where does the loaded javascript module go? Can I find them?

I am doing some research on a running website, and the behavior of the code just surprises me.

They defined a function named '__jsload' and bind it to window.

window._jsload = function(hJ, hK) {
        var i = d2.getModuleInfo(hJ);
        i.status = d2.Request.LOADED;
        if (hK !== "") {
            d2.run(hJ, hK)
        } else {
            if (window.map) {
                var e = new a6("ongetmodules_fail");
                e.moduleName = hJ;
                window.map.fire(e)
            }
            var T = document.createElement("script");
            var hI = d2.MD5Mapping[hJ];
            T.src = d2.Config.jsModPath + hJ + "_" + hI + ".js";
            document.getElementsByTagName("head")[0].appendChild(T)
        }
    };

In the run function, there's only an eval(), it seems nothing is stored for future use.

run: function(T, hI) {
            var hM = this.getModuleInfo(T);
            var hP = this.Dependency[T];
            if (hP) {
                for (var hK = 0; hK < hP.length; hK++) {
                    var hL = this.getModuleInfo(hP[hK]);
                    if (hL.status !== this.Request.COMPLETED) {
                        hL.modsNeedToRun.push({
                            name: T,
                            code: hI
                        });
                        return
                    }
                }
            }
            try {
                eval(hI)
            } catch (hN) {
                return
            }
            hM.status = this.Request.COMPLETED;
            for (var hK = 0, hJ = hM.callbacks.length; hK < hJ; hK++) {
                hM.callbacks[hK]()
            }
            hM.callbacks.length = 0;
            for (hK = 0; hK < hM.modsNeedToRun.length; hK++) {
                var hO = hM.modsNeedToRun[hK];
                this.run(hO.name, hO.code)
            }
            hM.modsNeedToRun.length = 0
        },

Then all the module are written in the following manner.

/**/_jsload&&_jsload(
    // this should be the module name
    'glcommon', 

    // this should be the module content
    'function aO(e,i)......'
)

I have a little experience in coding in python, so I thought those loaded modules will be special objects, and I can access functions defined in the module by just calling them.

import pandas as pd

pd.DataFrame()

And I searched some references on coding in javascript, they mentioned something like 'import/export' and maybe 'require'. After importing the module, I can call exported function just by calling the name.

// in sayHi.js
export function sayHi(user) {
  alert(`Hello, ${user}!`);
}

// in main.js
import {sayHi} from './sayHi.js';

alert(sayHi); // function...
sayHi('John'); // Hello, John!

None of these things happens in that website I'm researching on. There's even no 'export' in the whole module text.

So, here rises my question.

1. Is it possible to call the function in a module in the web console? If it's not bound to the window object, will it still be possible?

2. We all know that currently a lot of web pages are dynamic, when a certain event happens, a certain function relate to it should be called. So, where are those functions saved? Are they still reachable during the web is running?

3.How can I debug modules like the above ones, when you can't get a pretty printed version of code and make some breakpoints? I tried to go step by step, but all the functions go into the text versioned module, and I can't make a breakpoint.