anchor.diff:                             (mapcar (lambda (engine) (apply 'make-search-engine engine))
                                      *my-search-engines*)))))"))
   
  -    (:h3 "URL-dispatchers")
  -    (:p "You can configure which actions to take depending on the URL to be
  +   (:h3 "URL-dispatchers")
  +   (:p "You can configure which actions to take depending on the URL to be
   loaded.  For instance, you can configure which Torrent program to start to load
   magnet links.  See the" (:code "url-dispatching-handler") " function
   documentation.")
   
  -    (:h3 "Downloads")
  -    (:p "See the " (command-markup 'list-downloads) " command and the "
  -        (:code "download-path") " buffer slot documentation.")
  -
  -    (:h3 "Proxy and Tor")
  -    (:p "See the " (:code "proxy-mode") " documentation.")
  -
  -    (:h3 "Blocker mode")
  -    (:p "This mode blocks access to websites related to especific hosts. To see
  +   (:h3 "Downloads")
  +   (:p "See the " (command-markup 'list-downloads) " command and the "
  +       (:code "download-path") " buffer slot documentation.")
  +
  +   (:h3 "Proxy and Tor")
  +   (:p "See the " (:code "proxy-mode") " documentation.")
  +
  +   (:h3 "Blocker mode")
  +   (:p "This mode blocks access to websites related to especific hosts. To see
   all hosts being blocked, execute command " (:code "describe-variable") ", choose variable "
   (:code "NYXT/BLOCKER-MODE:*DEFAULT-HOSTLIST*") ", and read data on "
   (:code "nyxt/blocker-mode:url-body") " slot." " To customize host blocking, read the "
   (:code "blocker-mode") " documentation.")
   
  -    (:h3 "Custom commands")
  -    (:p "Creating your own invokable commands is similar to creating a Common
  +   (:h3 "Custom commands")
  +   (:p "Creating your own invokable commands is similar to creating a Common
   Lisp function, except the form is " (:code "define-command") " instead of "
   (:code "defun") ". If you want this command to be invokable outside of
           the context of a mode, use " (:code "define-command-global") ".")
  -    (:p "Example:")
  -    (:pre (:code
  -           "(define-command-global bookmark-url ()
  +   (:p "Example:")
  +   (:pre (:code
  +          "(define-command-global bookmark-url ()
     \"Query the user which URL to bookmark.\"
     (let ((url (prompt
                 :prompt \"Bookmark URL\"
                 :sources (make-instance 'prompter:raw-source))))
       (bookmark-add url)))"))
  -    (:p "See the " (:code "prompt-buffer") " class documentation for how to write
  +   (:p "See the " (:code "prompt-buffer") " class documentation for how to write
   write custom prompt-buffers.")
   
  -    (:h3 "Hooks")
  -    (:p "Hooks provide a powerful mechanism to tweak the behaviour of various
  +   (:h3 "Hooks")
  +   (:p "Hooks provide a powerful mechanism to tweak the behaviour of various
   events that occur in the context of windows, buffers, modes, etc.")
  -    (:p "A hook holds a list of " (:i "handlers") ".  Handlers are named and
  +   (:p "A hook holds a list of " (:i "handlers") ".  Handlers are named and
   typed functions.  Each hook has a dedicated handler constructor.")
  -    (:p
  -     "Hooks can be 'run', that is, their handlers are run according to
  +   (:p
  +    "Hooks can be 'run', that is, their handlers are run according to
   the " (:code "combination") " slot of the hook.  This combination is a function
   of the handlers.  Depending on the combination, a hook can run the handlers
   either in parallel, or in order until one fails, or even " (:i "compose")
  -     " them (pass the result of one as the input of the next).  The handler types
  +    " them (pass the result of one as the input of the next).  The handler types
   specify which input and output values are expected.")
  -    (:p "Many hooks are executed at different points in Nyxt, among others:
  +   (:p "Many hooks are executed at different points in Nyxt, among others:
   ")
  -    (:ul
  -     (:li "Global hooks, such as " (:code "*after-init-hook*") ".")
  -     (:li "Window- or buffer-related hooks.")
  -     (:li "Commands 'before' and 'after' hooks.")
  -     (:li "Modes 'enable' and 'disable' hooks."))
  -    (:p "For instance, if you want to force 'old.reddit.com' over 'www.reddit.com', you
  +   (:ul
  +    (:li "Global hooks, such as " (:code "*after-init-hook*") ".")
  +    (:li "Window- or buffer-related hooks.")
  +    (:li "Commands 'before' and 'after' hooks.")
  +    (:li "Modes 'enable' and 'disable' hooks."))
  +   (:p "For instance, if you want to force 'old.reddit.com' over 'www.reddit.com', you
   can set a hook like the following in your configuration file:")
  -    (:pre (:code "
  +   (:pre (:code "
   \(defun old-reddit-handler (request-data)
     (let ((url (url request-data)))
       (setf (url request-data)
  
positive.code:    (config-content)))
  
  (defun config-content ()
    (spinneret:with-html-string (:h2 "Configuration")
      (:p "Nyxt is written in the Common Lisp programming language which offers a
  great perk: everything in the browser can be customized by the user, even while
  it's running!")
      (:p "To get started with Common Lisp, we recommend checking out
      our web page: "
          (:a :href "https://nyxt.atlas.engineer/learn-lisp" "Learn Lisp")
          ". It contains numerous pointers to other resources, including
          free books both for beginners and seasoned programmers.")
      (:p "Nyxt provides a mechanism for new users unfamiliar with Lisp to
  customize Nyxt. Start by invoking the commands " (command-markup 'describe-class) "
  or " (command-markup 'describe-slot) ".  You can press the button marked 'Configure' to
  change the value of a setting. The settings will be applied immediately and
  saved for future sessions. Please note that these settings will not alter
  existing object instances.")
      (:p "Settings created by Nyxt are stored in "
          (:code (nfiles:expand *auto-config-file*)) ".")
      (:p "Any settings can be overridden manually by "
          (:code (nfiles:expand *init-file*)) ".")
      (:p "The following section assumes knowledge of basic Common Lisp or a
  similar programming language.")
      (:p "The user needs to manually create the Nyxt configuration file "
          (:code (nfiles:expand *init-file*))
          ", and the parent folders if necessary. You can also press the button
  below to create said file, if it's not created yet.")
       (let ((init-file-path (nfiles:expand *init-file*)))
         (:p (if (uiop:file-exists-p init-file-path)
                 (:a :class "button"
                     :href (ps:ps (nyxt/ps:lisp-eval `(echo "Init file exists")))
                     "Init file exists")
                 (:a :class "button"
                     :href (ps:ps (nyxt/ps:lisp-eval
                                   `(progn (ensure-directories-exist ,init-file-path)
                                           (ensure-file-exists ,init-file-path)
                                           (echo "Init file created at ~a."
                                                 ,init-file-path))))
                     "Create init file"))))
      (:p "Example:")
      (:pre (:code "
  \(define-configuration buffer
    ((default-modes (append '(no-script-mode) %slot-default%))))"))
      (:p "The above turns on the 'no-script-mode' (disables JavaScript) by default for
  every buffer.")
      (:p "The " (:code "define-configuration") " macro can be used to customize
  the slots of classes like the browser, buffers, windows, etc.  Refer to the
  class and slot documentation for the individual details.")
      (:p "To find out about all modes known to Nyxt,
  run " (command-markup 'describe-command) " and type 'mode'.")
  
      (:h3 "Slot configuration")
      (:p "Slots store values that can be either accessed (get) or changed
  (set). Setting new values for slots allows many possibilities of customization.
  For instance, keyboard layouts vary across the world. The slot "
          (:code "hints-alphabet")
          " has the default value of "
          (:code "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
          ". If the user has an American keyboard, they can do:")
      (:ol
       (:li "Execute command " (command-markup 'describe-slot) ";")
       (:li "Type " (:code 'hints-alphabet)";")
       (:li "Select " (:code "hints-alphabet") " (" (:code "user-web-mode") " class option);")
       (:li "Press the button " (:code "Configure") ", and;")
       (:li "Insert the string \"asfdghjkl\"") ".")
      (:p "This will make link-hinting more comfortable for this user. In
  addition, other similar approaches of customization can be applied to slots
  such as " (:code "spell-check-language") ", which can be expanded to do the
  spelling-check of other languages besides English.")
      (:h3 "Web buffers and internal buffers")
      (:p "A `internal-buffer' is used for Nyxt-specific, internal pages such as the
  tutorial and the description pages.  A `web-buffer' is used for web pages.  Both
  the `web-buffer' and the `internal-buffer' classes inherit from the `buffer'
  class.")
      (:p "You can configure a `buffer' slot and it will cascade down as a new
  default for both the `internal-buffer' and `web-buffer' classes- unless this slot
  is specialized by these child classes.")
  
      (:h3 "Keybinding configuration")
      (:p "Nyxt supports multiple " (:i "bindings schemes") " such as CUA (the
      default), Emacs or vi.  Changing scheme is as simple as running the
      corresponding mode, e.g. "
          (:code "emacs-mode") ".  To make the change persistent across sessions,
  add the following to your configuration:")
      (:ul
       (:li "vi bindings:"
            (:pre (:code "
  \(define-configuration buffer
    ((default-modes (append '(vi-normal-mode) %slot-default%))))")))
       (:li "Emacs bindings:"
            (:pre (:code "
  \(define-configuration buffer
    ((default-modes (append '(emacs-mode) %slot-default%))))"))))
      (:p "You can create new scheme names with " (:code "keymap:make-scheme-name")
          ".  Also see the " (:code "scheme-name") " class and the "
          (:code "define-scheme") " macro.")
      (:p "To extend the bindings of a specific mode, you can extend the mode with "
          (:code "define-configuration") " and extend its binding scheme with "
          (:code "define-scheme") ". For example:")
      (:pre (:code "
  \(define-configuration base-mode
    ((keymap-scheme
      (define-scheme (:name-prefix \"my-base\" :import %slot-default%)
        scheme:vi-normal
        (list \"g b\" (make-command switch-buffer* ()
                      (switch-buffer :current-is-last-p t)))))))"))
      (:p "The " (:code "override-map") " is a keymap that has priority over
  all other keymaps.  By default, it has few bindings like the one
  for " (command-markup 'execute-command) ".  You can use it to set keys globally:")
      (:pre (:code "
  \(define-configuration buffer
    ((override-map (let ((map (make-keymap \"override-map\")))
                     (define-key map
                       \"M-x\" 'execute-command
                       \"C-space\" 'nothing)))))"))
      (:p "The " (:code "nothing") " command is useful to override bindings to do
  nothing. Note that it's possible to bind any command, including those of
  disabled modes that are not listed in " (command-markup 'execute-command) ".")
      (:p "In addition, a more flexible approach is to create your own mode with
  your custom keybindings.  When this mode is added first to the buffer mode list,
  its keybindings have priorities over the other modes.
  Note that this kind of global keymaps also have priority over regular character
  insertion, so you should probably not bind anything without modifiers in such a
  keymap.")
      (:pre (:code "
  \(defvar *my-keymap* (make-keymap \"my-map\"))
  \(define-key *my-keymap*
    \"C-f\" 'nyxt/web-mode:history-forwards
  
negative.code:   ((search-engines (append (mapcar (lambda (engine) (apply 'make-search-engine engine))
                                     *my-search-engines*)
                             %slot-default%))))"))
     (:p "Note that the last search engine is the default one. For example, in
  order to make python3 the default, the above code can be slightly modified as
  follows.")
     (:pre (:code "
  \(defvar *my-search-engines*
    (list
     '(\"doi\" \"https://dx.doi.org/~a\" \"https://dx.doi.org/\")
  