// changes to the source will be reflected in the live array:

ids[1] = "my-cancel-button";
console.log(elements[1]); //

`

Methods

The following methods mimic those of a normal array:

* map
* forEach
* filter
* at
* find
* findIndex
* some
* every
* join
* reduce
* includes
* indexOf
* lastIndexOf
* slice

The following methods are unique to a LiveArray:

$3

Creates a new LiveArray that performs further transformation on read and write.

If set is provided, changes carry both ways:
`ts
const base = [2, 3, 4];
const doubles = liveArray(base).mapLive(n => n * 2, n => n / 2);
// ^ get ^ set
console.log(doubles[0]); // 4
doubles[0] = 100;
console.log(base[0]); // 50
`

$3

Creates a new LiveArray from a range within the parent

`ts
const base = [1, 2, 3, 4, 5, 6];
const doubles = liveArray(base, n => n * 2);
const slice = base.sliceLive(2, 4);

console.log(slice.length); // 2
base[2] = 100;
console.log(slice[0]); // 200
`

$3

Creates a new LiveArray that reads the parent in reverse order.

`ts
const words = ["world"];
const live = liveArray(words);
const backwards = live.reverseLive();

words.push("hello");
console.log(backwards.join(" ")); // "hello world"
`

$3

Creates a new LiveArray that reads the parent with automatic value caching.

If invalidator is provided, it will be called for every value read where the value is already cached, and passed an object of

`ts
{
ageMs: number; // ms since the value was cached
value: T; // the cached value
index: number;
cacheCount: number; // the number of items currently cached
}
`

If invalidator returns true, the cache entry is considered invalid. The value will then be recalculated, as normal, by the parent's provided get.

`ts
function expensiveHash(s: string) {
for (let i = 0; i < 100000000; i++) s = getHash(s);
return s;
}

const keys = ["banana", "sausage", "lemon", "treacle", "shoes", "elephant"];
const hashes = liveArray(keys, expensiveHash).withCache();
`

Advanced example with smart invalidation:

`ts
const hashes = liveArray({
getLength: () => keys.length,
get: idx => ({
key: keys[idx],
hash: expensiveHash(keys[idx]),
}),
})
// invalidate cache entries where the key has changed
.withCache(entry => entry.value.key !== keys[entry.index])
// but return only the hash
.mapLive(v => v.hash);
``