anchor.diff:     (make-instance 'nyxt/file-manager-mode:user-file-source
                     :extensions '("lisp")
                     :actions (list (make-command load-file* (files)
  -                                               (dolist (file files)
  -                                                 (load-lisp file)))))))
  +                                   (dolist (file files)
  +                                     (load-lisp file)))))))
   
   (define-command load-init-file (&key (init-file (nfiles:expand *init-file*)))
     "Load or reload the init file."
  
positive.code:                                                        #'symbol-name
                                                         #'opts::name)
                                           opts::*options*))
    (format nil "Parse command line or REPL options then start the browser.
  Load URLS if any (a list of strings).
  
  This functions focuses on OPTIONS parsing, see `start-browser' for the actual
  
negative.code: 
    ;; Options should be accessible anytime, even when run from the REPL.
    (setf *options* options)
    (destructuring-bind (&key headless verbose 
                           help version system-information
                           list-profiles script
                           load eval quit remote
                         &allow-other-keys)
        options 
      (when headless 
        (setf *headless-p* t))
      
      (if verbose 
          (progn
            (log:config :debug)
            (format t "Arguments parsed: ~a and ~a~&" options urls))
          (log:config :pattern "<%p> [%D{%H:%M:%S}] %m%n"))
  
      (cond 
        (help
         (opts:describe :prefix "nyxt [options] [URLs]"))
        
        (version
         (format t "Nyxt version ~a~&" +version+))
        
        (system-information
         (princ (system-information)))
        
        (list-profiles
         (load-lisp (nfiles:expand *init-file*) :package (find-package :nyxt-user))
         (mapcar (lambda (profile-class)
                   (format t "~a~10t~a~&"
                           (profile-class-name profile-class)
                           (indent (documentation profile-class t) 10)))
                 (list-profile-classes)))
        
        (script
         (flet ((run-script (stream)
                  (maybe-skip-shebang-line stream)
                  (load-lisp stream)))
           (match (getf options :script)
             ("-" (run-script *standard-input*))
             (file (with-open-file (f file :element-type :default)
                     (run-script f))))))
        
        ((and (or load eval)
              (or quit remote))
         (start-load-or-eval))
        (t
         (with-protect ("Error: ~a" :condition)
           (start-browser urls))))
      (unless *run-from-repl-p* (uiop:quit))))
  
  (defun load-or-eval (&key remote)
    (loop for (opt value . nil) on *options*
  