docs: def load_module_in_background(name, package=None, debug='DEBUG', env=None,
                                replacements=None):
      """Entry point for loading modules in background thread.
  
      Parameters
      ----------
      name : str
          Module name to load in background thread.
      package : str or None, optional
          Package name, has the same meaning as in importlib.import_module().
      debug : str, optional
          Debugging symbol name to look up in the environment.
      env : Mapping or None, optional
          Environment this will default to __xonsh_env__, if available, and
          os.environ otherwise.
      replacements : Mapping or None, optional
          Dictionary mapping fully qualified module names (eg foo.bar.baz) that
          import the lazily loaded moudle, with the variable name in that
          module. For example, suppose that foo.bar imports module a as b,
          this dict is then {'foo.bar': 'b'}.
  
      Returns
      -------
      module : ModuleType
          This is either the original module that is found in sys.modules or
          a proxy module that will block until delay attribute access until the
          module is fully loaded.
      """
      modname = resolve_name(name, package)
      if modname in sys.modules:
          return sys.modules[modname]
      if env is None:
          try:
              import builtins
              env = getattr(builtins, '__xonsh_env__', os.environ)
          except:
              return os.environ
      if env.get(debug, None):
          mod = importlib.import_module(name, package=package)
          return mod
      proxy = sys.modules[modname] = BackgroundModuleProxy(modname)
      BackgroundModuleLoader(name, package, replacements or {})
      return proxy