Overload one function by argument shape

JavaScript has no real overloading, so libraries fake it by inspecting arguments: attr("href") reads, attr("href", url) writes, attr({ ... }) writes many. Done carelessly this is a mess; done deliberately it is a genuinely pleasant API, and writing one teaches you to branch on argument count and type rather than on a flag.

Implement createSettings(initial = {}). It returns a *function* settings that closes over the store and behaves four ways. Called with no arguments, it returns a shallow copy of the whole store, so mutating the returned object does not change the store. Called with one string, it returns that key's value, or undefined if the key was never set. Called with a string and a second argument, it sets that key to that value and returns the settings function itself, so writes can be chained. Called with one plain object, it merges those entries into the store, overwriting existing keys, and also returns the settings function itself.

const settings = createSettings({ theme: "dark" });

settings("theme");             // "dark" — read
settings("locale", "en-IN");   // sets, returns settings
settings({ a: 1, b: 2 });      // merges, returns settings
settings();                    // { theme: "dark", locale: "en-IN", a: 1, b: 2 }

const settings = createSettings();
settings("a", 1)("b", 2); // chains, because writes return settings

const snapshot = settings();
snapshot.a = 999;
settings("a"); // 1 — the snapshot is a copy