anchor.diff:    (with-data-unsafe (history (history-path buffer))
       (sera:and-let* ((owner (htree:owner history (id buffer)))
                       (parent-id (htree:creator-id owner)))
  -      (gethash parent-id (buffers *browser*)))))
  +                   (gethash parent-id (buffers *browser*)))))
   
   (defun buffer-children (&optional (buffer (current-buffer)))
     (let* ((current-history (get-data (history-path buffer)))
  
positive.code:   (ffi-buffer-evaluate-javascript
     buffer
     (ps:ps
       (defvar nyxt-identifier-counter 0)
       (defun add-nyxt-identifiers (node)
         (unless (ps:chain node (has-attribute "nyxt-identifier"))
           (ps:chain node (set-attribute "nyxt-identifier" (ps:stringify nyxt-identifier-counter))))
         (incf nyxt-identifier-counter)
         (dolist (child (ps:chain node children))
           (add-nyxt-identifiers child))
         nyxt-identifier-counter)
       (setf nyxt-identifier-counter (add-nyxt-identifiers (ps:chain document body)))))
    (alex:when-let ((body-json (nyxt/dom::get-document-body-json)))
      (setf (document-model buffer)
            (nyxt/dom::named-json-parse body-json))))
  
  (defun dead-buffer-p (buffer) ; TODO: Use this wherever needed.
    (str:empty? (id buffer)))
  
negative.code: When there is no next buffer, go to the first one so as to cycle."
    (labels ((buffer-first-root (buffer)
               (alex:if-let ((parent (buffer-parent buffer)))
                            (buffer-first-root parent)
                            (first (first (buffer-siblings buffer)))))
             (buffer-next-parent-sibling (buffer)
               (alex:when-let ((parent (buffer-parent buffer)))
                              (alex:if-let ((next-siblings (second (buffer-siblings parent))))
                                           (first next-siblings)
                                           (buffer-next-parent-sibling parent))))
             (buffer-sibling-next (&optional (buffer (current-buffer)))
               (first (second (buffer-siblings buffer)))))
      (alex:when-let ((next (or (first (buffer-children buffer))
                                (buffer-sibling-next buffer)
                                (buffer-next-parent-sibling buffer)
                                (buffer-first-root buffer))))
                     (set-current-buffer next))))
  
  (define-command switch-buffer-last ()
    "Switch to the last showing buffer in the list of buffers.
  