To clone, or not to clone

Cloning or deep copy of objects is not supported directly in the JavaScript language, so you have to rely on a third party library, or roll your own.
You may object and say that there are the Object.create, and Object.assign functions that can do that, right? Wrong. They maintain references to the original object. If you change a property on the source object, it will affect the target object. This is only true if you change a property of a property though.
If you google for JavaScript deep copy or clone, you will find that there tons of tutorials, and articles, even frameworks that address this topic.
Some suggests using the builtin JSON object to stringify, and then parse. This method has the problem of not being able to convert back from a Date object for instance, and it doesn't handle functions because they are not part of JSON.
Others suggest to iterate over the properties, and do it recursively when you come across properties that are themselves objects. This method is possible, but has implications on performance, and problems like how to handle cyclic references, and how to maintain the prototype chain.

Just don't do it

Future I suggest that you just don't do it. Think about why cloning is needed in your design. Perhaps you have an immutable object that you actually want to modify. Well, maybe that object shouldn't be immutable then? Perhaps you are passing a complex object to a function, and you are worried that the function will modify the original object, then make the original object immutable instead. Perhaps you should pass a new object that are created from a select set of the properties instead.
I challenge you to think about whether cloning is just a sign of bad design.
I recently came across a situation where I thought I needed to clone a model object. The model contains a history of changes to the model. I needed a future state of the model without modifying the actual model. I discovered that I could create a derived object, and just override the parts that exposed that part of the model to the rest of the program.
This is a chess program, and the model was the current state of the game. There is a peek method that returns the piece on a certain square of the board.
This is how I implemented the derived object:

var Chess = Chess || {};  
Chess.Future = function(model, move) {  
  var that = Object.create(model);
  that.peek = function(square) {
    if(square.file === move.to.file && square.rank === move.to.rank) {
      return model.peek({file: move.from.file, rank: move.from.rank});
    }
    if(square.file === move.from.file && square.rank === move.from.rank) {
      return undefined;
    }
    return model.peek(square);
  };
  return that;
};

I pass in the original model and the chess move to the constructor of the Future object. I create a derived object from model using the Object.create method. I then override the peek method. If the square is the same as the destination square of the move, the returned value is the piece on that square in the original model. I the square is the same as the origin square of the move, undefined is returned meaning empty square. If none of these conditions are met, I return the result of calling the peek method on the original model.

Please comment on this post. I am curious if there are situations where cloning is required, and why.