Singly Linked list partial traversal. Before node that references the dummy node is different than it at the end. How is this possible

Question

Below I have some code to implement a singly linked list which implements the following

Given the head of a singly linked list and two integers left and right where left <= right, reverse the nodes of the list from position left to position right, and return the reversed list.

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} left
 * @param {number} right
 * @return {ListNode}
 */
var reverseBetween = function(head, left, right){
    // represents number of the node we are on
    let dummy = new ListNode(-1,head)
    let before = dummy
   
    for (let i = 1; i < left; i++) {
        before = before.next
    }

    console.log(before) // [1,2,3,4,5]
    console.log(dummy) //  [-1,1,2,3,4,5]

    let prev = before
    let current = before.next
 
    for (let i = left; i <= right; i++) {
       
            let next = current.next
            current.next = prev
            prev = current
            current = next
    
    }
    
    before.next.next = current
    before.next = prev
    console.log("before =", before) // [1,4,3,2,5]
    console.log("dummy = ", dummy) //  [-1,1,4,3,2,5]
    return dummy.next
}

The code below works for all inputs, but it's a mystery to me why, at the bottom, the before and dummy variables are sometimes different. For instance, for the following inputs

head = [1,2,3,4,5] left = 2 right = 4

The console statements at the bottom of the page read

before = [1,4,3,2,5]
dummy = [-1,1,4,3,2,5]

As far as i understand it, classes are value by reference in javascript, so changes to the 'dummy' or 'before' objects' properties would always update each other. However, I understand that

before = before.next

would give the before object a new the address, which we see when we console.log the before and dummy variables higher up (before = [1,2,3,4,5], dummy = [-1,1,2,3,4,5])

But what is confusing me is that when we then go and modify and reverse before, the order of the dummy variable is still modified, despite apparently pointing to a different spot in memory. I'm wondering why 'dummy' and 'before' are still tracking each other at the end of the algorithm, despite the re-assignment of before at the top of the function.