tinybase 0.0.0 → 0.9.3

package/lib/debug/tinybase.js

@@ -0,0 +1,1708 @@
+import {promises, watch} from 'fs';
+
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_OBJECT = '{}';
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const FUNCTION = getTypeOf(getTypeOf);
+const TYPE = 'type';
+const DEFAULT = 'default';
+const UTF8 = 'utf8';
+const SUM = 'sum';
+const AVG = 'avg';
+const MIN = 'min';
+const MAX = 'max';
+
+const arrayHas = (array, value) => array.includes(value);
+const arrayIsSorted = (array, sorter) =>
+  array.every(
+    (value, index) => index == 0 || sorter(array[index - 1], value) <= 0,
+  );
+const arraySort = (array, sorter) => array.sort(sorter);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
+const arrayLength = (array) => array.length;
+const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arrayFilter = (array, cb) => array.filter(cb);
+const arrayFromSecond = (ids) => ids.slice(1);
+const arrayClear = (array, to) => array.splice(0, to);
+
+const jsonString = (obj) =>
+  JSON.stringify(obj, (_key, value) =>
+    isInstanceOf(value, Map)
+      ? arrayReduce(
+          [...value],
+          (obj2, [key, value2]) => {
+            obj2[key] = value2;
+            return obj2;
+          },
+          {},
+        )
+      : value,
+  );
+const jsonParse = JSON.parse;
+const mathMax = Math.max;
+const mathMin = Math.min;
+const isFiniteNumber = isFinite;
+const isInstanceOf = (thing, cls) => thing instanceof cls;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isString = (thing) => getTypeOf(thing) == STRING;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+const getUndefined = () => void 0;
+
+const collSizeN = (collSizer) => (coll) =>
+  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
+const collSize = (coll) => coll.size;
+const collSize2 = collSizeN(collSize);
+const collSize3 = collSizeN(collSize2);
+const collSize4 = collSizeN(collSize3);
+const collPairSize = (pair, func = collSize) => func(pair[0]) + func(pair[1]);
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapNewPair = (newFunction = mapNew) => [newFunction(), newFunction()];
+const mapKeys = (map) => [...(map?.keys() ?? [])];
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, defaultValue, onWillAdd) => {
+  if (!collHas(map, key)) {
+    onWillAdd?.(defaultValue);
+    map.set(key, defaultValue);
+  }
+  return mapGet(map, key);
+};
+const mapToObj = (map, childMapper) => {
+  const obj = {};
+  const mapper = childMapper ?? ((mapValue) => mapValue);
+  collForEach(map, (value, key) => (obj[key] = mapper(value)));
+  return obj;
+};
+const mapClone = (map, childMapper) => {
+  const map2 = mapNew();
+  const mapper = childMapper ?? ((mapValue) => mapValue);
+  collForEach(map, (value, key) => map2.set(key, mapper(value)));
+  return map2;
+};
+
+const setNew = (entries) => new Set(entries);
+const setAdd = (set, value) => set?.add(value);
+
+const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
+  const hasRow = store.hasRow;
+  const tableIds = mapNew();
+  const things = mapNew();
+  const allRowValues = mapNew();
+  const allSortKeys = mapNew();
+  const storeListenerIds = mapNew();
+  const getStore = () => store;
+  const getThingIds = () => mapKeys(tableIds);
+  const getTableId = (id) => mapGet(tableIds, id);
+  const getThing = (id) => mapGet(things, id);
+  const setThing = (id, thing) => mapSet(things, id, thing);
+  const removeStoreListeners = (id) =>
+    ifNotUndefined(mapGet(storeListenerIds, id), (listenerIds) => {
+      collForEach(listenerIds, store.delListener);
+      mapSet(storeListenerIds, id);
+    });
+  const setDefinition = (id, tableId, onChanged, getRowValue, getSortKey) => {
+    const changedRowValues = mapNew();
+    const changedSortKeys = mapNew();
+    mapSet(tableIds, id, tableId);
+    if (!collHas(things, id)) {
+      mapSet(things, id, getDefaultThing());
+      mapSet(allRowValues, id, mapNew());
+      mapSet(allSortKeys, id, mapNew());
+    }
+    const rowValues = mapGet(allRowValues, id);
+    const sortKeys = mapGet(allSortKeys, id);
+    const processRow = (rowId) => {
+      const getCell = (cellId) => store.getCell(tableId, rowId, cellId);
+      const oldRowValue = mapGet(rowValues, rowId);
+      const newRowValue = hasRow(tableId, rowId)
+        ? validateRowValue(getRowValue(getCell, rowId))
+        : void 0;
+      if (oldRowValue != newRowValue) {
+        mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);
+      }
+      if (!isUndefined(getSortKey)) {
+        const oldSortKey = mapGet(sortKeys, rowId);
+        const newSortKey = hasRow(tableId, rowId)
+          ? getSortKey(getCell, rowId)
+          : void 0;
+        if (oldSortKey != newSortKey) {
+          mapSet(changedSortKeys, rowId, newSortKey);
+        }
+      }
+    };
+    const processTable = (force) => {
+      onChanged(
+        () => {
+          collForEach(changedRowValues, ([, newRowValue], rowId) =>
+            mapSet(rowValues, rowId, newRowValue),
+          );
+          collForEach(changedSortKeys, (newSortKey, rowId) =>
+            mapSet(sortKeys, rowId, newSortKey),
+          );
+        },
+        changedRowValues,
+        changedSortKeys,
+        rowValues,
+        sortKeys,
+        force,
+      );
+      collClear(changedRowValues);
+      collClear(changedSortKeys);
+    };
+    mapForEach(rowValues, processRow);
+    if (store.hasTable(tableId)) {
+      arrayForEach(store.getRowIds(tableId), (rowId) => {
+        if (!collHas(rowValues, rowId)) {
+          processRow(rowId);
+        }
+      });
+    }
+    processTable(true);
+    removeStoreListeners(id);
+    mapSet(
+      storeListenerIds,
+      id,
+      setNew([
+        store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
+          processRow(rowId),
+        ),
+        store.addTableListener(tableId, () => processTable()),
+      ]),
+    );
+  };
+  const delDefinition = (id) => {
+    mapSet(tableIds, id);
+    mapSet(things, id);
+    mapSet(allRowValues, id);
+    mapSet(allSortKeys, id);
+    removeStoreListeners(id);
+  };
+  const destroy = () => mapForEach(storeListenerIds, delDefinition);
+  return [
+    getStore,
+    getThingIds,
+    getTableId,
+    getThing,
+    setThing,
+    setDefinition,
+    delDefinition,
+    destroy,
+  ];
+};
+const getRowCellFunction = (getRowCell, defaultCellValue) =>
+  isString(getRowCell)
+    ? (getCell) => getCell(getRowCell)
+    : getRowCell ?? (() => defaultCellValue ?? EMPTY_STRING);
+const getCreateFunction = (getFunction) => {
+  const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
+  return (store) => {
+    if (!getFunctionsByStore.has(store)) {
+      getFunctionsByStore.set(store, getFunction(store));
+    }
+    return getFunctionsByStore.get(store);
+  };
+};
+
+const addDeepSet = (deepSet, value, ids) =>
+  arrayLength(ids) < 2
+    ? setAdd(
+        arrayIsEmpty(ids) ? deepSet : mapEnsure(deepSet, ids[0], setNew()),
+        value,
+      )
+    : addDeepSet(
+        mapEnsure(deepSet, ids[0], mapNew()),
+        value,
+        arrayFromSecond(ids),
+      );
+const forDeepSet = (valueDo) => {
+  const deep = (deepIdSet, arg, ...ids) =>
+    ifNotUndefined(deepIdSet, (deepIdSet2) =>
+      arrayIsEmpty(ids)
+        ? valueDo(deepIdSet2, arg)
+        : arrayForEach([ids[0], null], (id) =>
+            deep(mapGet(deepIdSet2, id), arg, ...arrayFromSecond(ids)),
+          ),
+    );
+  return deep;
+};
+const getListenerFunctions = (getThing) => {
+  let thing;
+  let nextId = 0;
+  const listenerPool = [];
+  const allListeners = mapNew();
+  const addListener = (listener, deepSet, idOrNulls = []) => {
+    thing ??= getThing();
+    const id = listenerPool.pop() ?? '' + nextId++;
+    mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
+    addDeepSet(deepSet, id, idOrNulls);
+    return id;
+  };
+  const callListeners = (deepSet, ids = [], ...extraArgs) =>
+    forDeepSet(collForEach)(
+      deepSet,
+      (id) =>
+        ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
+          listener(thing, ...ids, ...extraArgs),
+        ),
+      ...ids,
+    );
+  const delListener = (id) =>
+    ifNotUndefined(
+      mapGet(allListeners, id),
+      ([, deepSet, idOrNulls]) => {
+        forDeepSet(collDel)(deepSet, id, ...idOrNulls);
+        mapSet(allListeners, id);
+        if (arrayLength(listenerPool) < 1e3) {
+          listenerPool.push(id);
+        }
+        return idOrNulls;
+      },
+      () => [],
+    );
+  const callListener = (id, idNullGetters, extraArgsGetter) =>
+    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls]) => {
+      const callWithIds = (...ids) => {
+        const index = arrayLength(ids);
+        index == arrayLength(idOrNulls)
+          ? listener(thing, ...ids, ...extraArgsGetter(ids))
+          : isUndefined(idOrNulls[index])
+          ? arrayForEach(idNullGetters[index](...ids), (id2) =>
+              callWithIds(...ids, id2),
+            )
+          : callWithIds(...ids, idOrNulls[index]);
+      };
+      callWithIds();
+    });
+  return [addListener, callListeners, delListener, callListener];
+};
+
+const object = Object;
+const objIds = object.keys;
+const objFrozen = object.isFrozen;
+const objFreeze = object.freeze;
+const isObject = (obj) =>
+  isInstanceOf(obj, object) && obj.constructor == object;
+const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
+const objHas = (obj, id) => !isUndefined(objGet(obj, id));
+const objDel = (obj, id) => delete obj[id];
+const objForEach = (obj, cb) =>
+  arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
+const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
+
+const createCheckpoints = getCreateFunction((store) => {
+  let backwardIdsSize = 100;
+  let currentId;
+  let delta = mapNew();
+  let listening = 1;
+  let nextCheckpointId;
+  let checkpointsChanged;
+  const checkpointIdsListeners = setNew();
+  const checkpointListeners = mapNew();
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => checkpoints,
+  );
+  const deltas = mapNew();
+  const labels = mapNew();
+  const backwardIds = [];
+  const forwardIds = [];
+  const updateStore = (oldOrNew, checkpointId) => {
+    listening = 0;
+    store.transaction(() =>
+      collForEach(mapGet(deltas, checkpointId), (table, tableId) =>
+        collForEach(table, (row, rowId) =>
+          collForEach(row, (oldNew, cellId) =>
+            isUndefined(oldNew[oldOrNew])
+              ? store.delCell(tableId, rowId, cellId, true)
+              : store.setCell(tableId, rowId, cellId, oldNew[oldOrNew]),
+          ),
+        ),
+      ),
+    );
+    listening = 1;
+  };
+  const clearCheckpointId = (checkpointId) => {
+    mapSet(deltas, checkpointId);
+    mapSet(labels, checkpointId);
+    callListeners(checkpointListeners, [checkpointId]);
+  };
+  const clearCheckpointIds = (checkpointIds, to) =>
+    arrayForEach(
+      arrayClear(checkpointIds, to ?? arrayLength(checkpointIds)),
+      clearCheckpointId,
+    );
+  const trimBackwardsIds = () =>
+    clearCheckpointIds(backwardIds, arrayLength(backwardIds) - backwardIdsSize);
+  const listenerId = store.addCellListener(
+    null,
+    null,
+    null,
+    (_store, tableId, rowId, cellId, newCell, oldCell) => {
+      if (listening) {
+        ifNotUndefined(currentId, () => {
+          backwardIds.push(currentId);
+          trimBackwardsIds();
+          clearCheckpointIds(forwardIds);
+          currentId = void 0;
+          checkpointsChanged = 1;
+        });
+        const table = mapEnsure(delta, tableId, mapNew());
+        const row = mapEnsure(table, rowId, mapNew());
+        const oldNew = mapEnsure(
+          row,
+          cellId,
+          [void 0, void 0],
+          (addOldNew) => (addOldNew[0] = oldCell),
+        );
+        oldNew[1] = newCell;
+        if (oldNew[0] === oldNew[1]) {
+          if (collIsEmpty(mapSet(row, cellId))) {
+            if (collIsEmpty(mapSet(table, rowId))) {
+              if (collIsEmpty(mapSet(delta, tableId))) {
+                currentId = backwardIds.pop();
+                checkpointsChanged = 1;
+              }
+            }
+          }
+        }
+        callListenersIfChanged();
+      }
+    },
+  );
+  const addCheckpointImpl = (label = '') => {
+    if (isUndefined(currentId)) {
+      currentId = '' + nextCheckpointId++;
+      mapSet(deltas, currentId, delta);
+      setCheckpoint(currentId, label);
+      delta = mapNew();
+      checkpointsChanged = 1;
+    }
+    return currentId;
+  };
+  const goBackwardImpl = () => {
+    if (!arrayIsEmpty(backwardIds)) {
+      forwardIds.unshift(addCheckpointImpl());
+      updateStore(0, currentId);
+      currentId = backwardIds.pop();
+      checkpointsChanged = 1;
+    }
+  };
+  const goForwardImpl = () => {
+    if (!arrayIsEmpty(forwardIds)) {
+      backwardIds.push(currentId);
+      currentId = forwardIds.shift();
+      updateStore(1, currentId);
+      checkpointsChanged = 1;
+    }
+  };
+  const callListenersIfChanged = () => {
+    if (checkpointsChanged) {
+      callListeners(checkpointIdsListeners);
+      checkpointsChanged = 0;
+    }
+  };
+  const setSize = (size) => {
+    backwardIdsSize = size;
+    trimBackwardsIds();
+    return checkpoints;
+  };
+  const addCheckpoint = (label) => {
+    const id = addCheckpointImpl(label);
+    callListenersIfChanged();
+    return id;
+  };
+  const setCheckpoint = (checkpointId, label) => {
+    if (
+      collHas(deltas, checkpointId) &&
+      mapGet(labels, checkpointId) !== label
+    ) {
+      mapSet(labels, checkpointId, label);
+      callListeners(checkpointListeners, [checkpointId]);
+    }
+    return checkpoints;
+  };
+  const getStore = () => store;
+  const getCheckpointIds = () => [[...backwardIds], currentId, [...forwardIds]];
+  const getCheckpoint = (checkpointId) => mapGet(labels, checkpointId);
+  const goBackward = () => {
+    goBackwardImpl();
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const goForward = () => {
+    goForwardImpl();
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const goTo = (checkpointId) => {
+    const action = arrayHas(backwardIds, checkpointId)
+      ? goBackwardImpl
+      : arrayHas(forwardIds, checkpointId)
+      ? goForwardImpl
+      : null;
+    while (!isUndefined(action) && checkpointId != currentId) {
+      action();
+    }
+    callListenersIfChanged();
+    return checkpoints;
+  };
+  const addCheckpointIdsListener = (listener) =>
+    addListener(listener, checkpointIdsListeners);
+  const addCheckpointListener = (checkpointId, listener) =>
+    addListener(listener, checkpointListeners, [checkpointId]);
+  const delListener = (listenerId2) => {
+    delListenerImpl(listenerId2);
+    return checkpoints;
+  };
+  const clear = () => {
+    clearCheckpointIds(backwardIds);
+    clearCheckpointIds(forwardIds);
+    if (!isUndefined(currentId)) {
+      clearCheckpointId(currentId);
+    }
+    currentId = void 0;
+    nextCheckpointId = 0;
+    addCheckpoint();
+    return checkpoints;
+  };
+  const destroy = () => {
+    store.delListener(listenerId);
+  };
+  const getListenerStats = () => ({
+    checkpointIds: collSize(checkpointIdsListeners),
+    checkpoint: collSize2(checkpointListeners),
+  });
+  const checkpoints = {
+    setSize,
+    addCheckpoint,
+    setCheckpoint,
+    getStore,
+    getCheckpointIds,
+    getCheckpoint,
+    goBackward,
+    goForward,
+    goTo,
+    addCheckpointIdsListener,
+    addCheckpointListener,
+    delListener,
+    clear,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(checkpoints.clear());
+});
+
+const createIndexes = getCreateFunction((store) => {
+  const sliceIdsListeners = mapNew();
+  const sliceRowIdsListeners = mapNew();
+  const [
+    getStore,
+    getIndexIds,
+    getTableId,
+    getIndex,
+    setIndex,
+    setDefinition,
+    delDefinition,
+    destroy,
+  ] = getDefinableFunctions(store, mapNew, (value) =>
+    isUndefined(value) ? EMPTY_STRING : value + EMPTY_STRING,
+  );
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => indexes,
+  );
+  const setIndexDefinition = (
+    indexId,
+    tableId,
+    getSliceId,
+    getSortKey,
+    sliceIdSorter,
+    rowIdSorter = defaultSorter,
+  ) => {
+    const sliceIdArraySorter = isUndefined(sliceIdSorter)
+      ? void 0
+      : ([id1], [id2]) => sliceIdSorter(id1, id2);
+    setDefinition(
+      indexId,
+      tableId,
+      (change, changedSliceIds, changedSortKeys, sliceIds, sortKeys) => {
+        let sliceIdsChanged = 0;
+        const changedSlices = setNew();
+        const unsortedSlices = setNew();
+        const index = getIndex(indexId);
+        collForEach(changedSliceIds, ([oldSliceId, newSliceId], rowId) => {
+          if (!isUndefined(oldSliceId)) {
+            setAdd(changedSlices, oldSliceId);
+            ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {
+              collDel(oldSlice, rowId);
+              if (collIsEmpty(oldSlice)) {
+                mapSet(index, oldSliceId);
+                sliceIdsChanged = 1;
+              }
+            });
+          }
+          if (!isUndefined(newSliceId)) {
+            setAdd(changedSlices, newSliceId);
+            if (!collHas(index, newSliceId)) {
+              mapSet(index, newSliceId, setNew());
+              sliceIdsChanged = 1;
+            }
+            setAdd(mapGet(index, newSliceId), rowId);
+            if (!isUndefined(getSortKey)) {
+              setAdd(unsortedSlices, newSliceId);
+            }
+          }
+        });
+        change();
+        mapForEach(changedSortKeys, (rowId) =>
+          ifNotUndefined(mapGet(sliceIds, rowId), (sliceId) =>
+            setAdd(unsortedSlices, sliceId),
+          ),
+        );
+        if (!collIsEmpty(sortKeys)) {
+          collForEach(unsortedSlices, (sliceId) => {
+            const rowIdArraySorter = (rowId1, rowId2) =>
+              rowIdSorter(
+                mapGet(sortKeys, rowId1),
+                mapGet(sortKeys, rowId2),
+                sliceId,
+              );
+            const sliceArray = [...mapGet(index, sliceId)];
+            if (!arrayIsSorted(sliceArray, rowIdArraySorter)) {
+              mapSet(
+                index,
+                sliceId,
+                setNew(arraySort(sliceArray, rowIdArraySorter)),
+              );
+              setAdd(changedSlices, sliceId);
+            }
+          });
+        }
+        if (sliceIdsChanged) {
+          if (!isUndefined(sliceIdArraySorter)) {
+            const indexArray = [...index];
+            if (!arrayIsSorted(indexArray, sliceIdArraySorter)) {
+              setIndex(
+                indexId,
+                mapNew(arraySort(indexArray, sliceIdArraySorter)),
+              );
+            }
+          }
+          callListeners(sliceIdsListeners, [indexId]);
+        }
+        collForEach(changedSlices, (sliceId) =>
+          callListeners(sliceRowIdsListeners, [indexId, sliceId]),
+        );
+      },
+      getRowCellFunction(getSliceId),
+      ifNotUndefined(getSortKey, getRowCellFunction),
+    );
+    return indexes;
+  };
+  const delIndexDefinition = (indexId) => {
+    delDefinition(indexId);
+    return indexes;
+  };
+  const getSliceIds = (indexId) => mapKeys(getIndex(indexId));
+  const getSliceRowIds = (indexId, sliceId) =>
+    collValues(mapGet(getIndex(indexId), sliceId));
+  const addSliceIdsListener = (indexId, listener) =>
+    addListener(listener, sliceIdsListeners, [indexId]);
+  const addSliceRowIdsListener = (indexId, sliceId, listener) =>
+    addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return indexes;
+  };
+  const getListenerStats = () => ({
+    sliceIds: collSize2(sliceIdsListeners),
+    sliceRowIds: collSize3(sliceRowIdsListeners),
+  });
+  const indexes = {
+    setIndexDefinition,
+    delIndexDefinition,
+    getStore,
+    getIndexIds,
+    getTableId,
+    getSliceIds,
+    getSliceRowIds,
+    addSliceIdsListener,
+    addSliceRowIdsListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(indexes);
+});
+const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+
+const aggregators = mapNew([
+  [
+    AVG,
+    [
+      (numbers, length) => arraySum(numbers) / length,
+      (metric, add, length) => metric + (add - metric) / (length + 1),
+      (metric, remove, length) => metric + (metric - remove) / (length - 1),
+      (metric, add, remove, length) => metric + (add - remove) / length,
+    ],
+  ],
+  [
+    MAX,
+    [
+      (numbers) => mathMax(...numbers),
+      (metric, add) => mathMax(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMax(add, metric),
+    ],
+  ],
+  [
+    MIN,
+    [
+      (numbers) => mathMin(...numbers),
+      (metric, add) => mathMin(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMin(add, metric),
+    ],
+  ],
+  [
+    SUM,
+    [
+      (numbers) => arraySum(numbers),
+      (metric, add) => metric + add,
+      (metric, remove) => metric - remove,
+      (metric, add, remove) => metric - remove + add,
+    ],
+  ],
+]);
+const createMetrics = getCreateFunction((store) => {
+  const metricListeners = mapNew();
+  const [
+    getStore,
+    getMetricIds,
+    getTableId,
+    getMetric,
+    setMetric,
+    setDefinition,
+    delDefinition,
+    destroy,
+  ] = getDefinableFunctions(store, getUndefined, (value) =>
+    isNaN(value) ||
+    isUndefined(value) ||
+    value === true ||
+    value === false ||
+    value === EMPTY_STRING
+      ? void 0
+      : value * 1,
+  );
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => metrics,
+  );
+  const setMetricDefinition = (
+    metricId,
+    tableId,
+    aggregate,
+    getNumber,
+    aggregateAdd,
+    aggregateRemove,
+    aggregateReplace,
+  ) => {
+    const metricAggregators = isFunction(aggregate)
+      ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
+      : mapGet(aggregators, aggregate) ?? mapGet(aggregators, SUM);
+    setDefinition(
+      metricId,
+      tableId,
+      (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
+        let newMetric = getMetric(metricId);
+        let length = collSize(numbers);
+        const [aggregate2, aggregateAdd2, aggregateRemove2, aggregateReplace2] =
+          metricAggregators;
+        force = force || isUndefined(newMetric);
+        collForEach(changedNumbers, ([oldNumber, newNumber]) => {
+          if (!force) {
+            newMetric = isUndefined(oldNumber)
+              ? aggregateAdd2?.(newMetric, newNumber, length++)
+              : isUndefined(newNumber)
+              ? aggregateRemove2?.(newMetric, oldNumber, length--)
+              : aggregateReplace2?.(newMetric, newNumber, oldNumber, length);
+          }
+          force = force || isUndefined(newMetric);
+        });
+        change();
+        if (collIsEmpty(numbers)) {
+          newMetric = void 0;
+        } else if (force) {
+          newMetric = aggregate2(collValues(numbers), collSize(numbers));
+        }
+        if (!isFiniteNumber(newMetric)) {
+          newMetric = void 0;
+        }
+        const oldMetric = getMetric(metricId);
+        if (newMetric != oldMetric) {
+          setMetric(metricId, newMetric);
+          callListeners(metricListeners, [metricId], newMetric, oldMetric);
+        }
+      },
+      getRowCellFunction(getNumber, 1),
+    );
+    return metrics;
+  };
+  const delMetricDefinition = (metricId) => {
+    delDefinition(metricId);
+    return metrics;
+  };
+  const addMetricListener = (metricId, listener) =>
+    addListener(listener, metricListeners, [metricId]);
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return metrics;
+  };
+  const getListenerStats = () => ({metric: collSize2(metricListeners)});
+  const metrics = {
+    setMetricDefinition,
+    delMetricDefinition,
+    getStore,
+    getMetricIds,
+    getTableId,
+    getMetric,
+    addMetricListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(metrics);
+});
+
+const createCustomPersister = (
+  store,
+  getPersisted,
+  setPersisted,
+  startListeningToPersisted,
+  stopListeningToPersisted,
+) => {
+  let tablesListenerId;
+  let loadSave = 0;
+  let loads = 0;
+  let saves = 0;
+  const persister = {
+    load: async (initialTables) => {
+      /* istanbul ignore else */
+      if (loadSave != 2) {
+        loadSave = 1;
+        {
+          loads++;
+        }
+        const body = await getPersisted();
+        if (!isUndefined(body) && body != '') {
+          store.setJson(body);
+        } else {
+          store.setTables(initialTables);
+        }
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoLoad: async (initialTables) => {
+      persister.stopAutoLoad();
+      await persister.load(initialTables);
+      startListeningToPersisted(persister.load);
+      return persister;
+    },
+    stopAutoLoad: () => {
+      stopListeningToPersisted();
+      return persister;
+    },
+    save: async () => {
+      /* istanbul ignore else */
+      if (loadSave != 1) {
+        loadSave = 2;
+        {
+          saves++;
+        }
+        await setPersisted(store.getJson());
+        loadSave = 0;
+      }
+      return persister;
+    },
+    startAutoSave: async () => {
+      await persister.stopAutoSave().save();
+      tablesListenerId = store.addTablesListener(() => persister.save());
+      return persister;
+    },
+    stopAutoSave: () => {
+      ifNotUndefined(tablesListenerId, store.delListener);
+      return persister;
+    },
+    getStore: () => store,
+    destroy: () => persister.stopAutoLoad().stopAutoSave(),
+    getStats: () => ({loads, saves}),
+  };
+  return objFreeze(persister);
+};
+
+const STORAGE = 'storage';
+const WINDOW = globalThis.window;
+const getStoragePersister = (store, storageName, storage) => {
+  let listener;
+  const getPersisted = async () => storage.getItem(storageName);
+  const setPersisted = async (json) => storage.setItem(storageName, json);
+  const startListeningToPersisted = (didChange) => {
+    listener = (event) => {
+      if (event.storageArea === storage && event.key === storageName) {
+        didChange();
+      }
+    };
+    WINDOW.addEventListener(STORAGE, listener);
+  };
+  const stopListeningToPersisted = () => {
+    WINDOW.removeEventListener(STORAGE, listener);
+    listener = void 0;
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    startListeningToPersisted,
+    stopListeningToPersisted,
+  );
+};
+const createLocalPersister = (store, storageName) =>
+  getStoragePersister(store, storageName, localStorage);
+const createSessionPersister = (store, storageName) =>
+  getStoragePersister(store, storageName, sessionStorage);
+
+const createFilePersister = (store, filePath) => {
+  let watcher;
+  const getPersisted = async () => {
+    try {
+      return await promises.readFile(filePath, UTF8);
+    } catch {}
+  };
+  const setPersisted = async (json) => {
+    try {
+      await promises.writeFile(filePath, json, UTF8);
+    } catch {}
+  };
+  const startListeningToPersisted = (didChange) => {
+    watcher = watch(filePath, didChange);
+  };
+  const stopListeningToPersisted = () => {
+    watcher?.close();
+    watcher = void 0;
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    startListeningToPersisted,
+    stopListeningToPersisted,
+  );
+};
+
+const getETag = (response) => response.headers.get('ETag');
+const createRemotePersister = (
+  store,
+  loadUrl,
+  saveUrl,
+  autoLoadIntervalSeconds,
+) => {
+  let interval;
+  let lastEtag;
+  const getPersisted = async () => {
+    const response = await fetch(loadUrl);
+    lastEtag = getETag(response);
+    return response.text();
+  };
+  const setPersisted = async (json) =>
+    await fetch(saveUrl, {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: json,
+    });
+  const startListeningToPersisted = (didChange) => {
+    interval = setInterval(async () => {
+      const response = await fetch(loadUrl, {method: 'HEAD'});
+      const currentEtag = getETag(response);
+      if (
+        !isUndefined(lastEtag) &&
+        !isUndefined(currentEtag) &&
+        currentEtag != lastEtag
+      ) {
+        lastEtag = currentEtag;
+        didChange();
+      }
+    }, autoLoadIntervalSeconds * 1e3);
+  };
+  const stopListeningToPersisted = () => {
+    ifNotUndefined(interval, clearInterval);
+    interval = void 0;
+  };
+  return createCustomPersister(
+    store,
+    getPersisted,
+    setPersisted,
+    startListeningToPersisted,
+    stopListeningToPersisted,
+  );
+};
+
+const createRelationships = getCreateFunction((store) => {
+  const remoteTableIds = mapNew();
+  const remoteRowIdListeners = mapNew();
+  const localRowIdsListeners = mapNew();
+  const linkedRowIdsListeners = mapNew();
+  const [
+    getStore,
+    getRelationshipIds,
+    getLocalTableId,
+    getRelationship,
+    _setRelationship,
+    setDefinition,
+    delDefinition,
+    destroy,
+  ] = getDefinableFunctions(
+    store,
+    () => [mapNew(), mapNew(), mapNew(), mapNew()],
+    (value) => (isUndefined(value) ? void 0 : value + EMPTY_STRING),
+  );
+  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
+    () => relationships,
+  );
+  const getLinkedRowIdsCache = (relationshipId, firstRowId, skipCache) =>
+    ifNotUndefined(
+      getRelationship(relationshipId),
+      ([remoteRows, , linkedRowsCache]) => {
+        if (!collHas(linkedRowsCache, firstRowId)) {
+          const linkedRows = setNew();
+          if (
+            getLocalTableId(relationshipId) != getRemoteTableId(relationshipId)
+          ) {
+            setAdd(linkedRows, firstRowId);
+          } else {
+            let rowId = firstRowId;
+            while (!isUndefined(rowId) && !collHas(linkedRows, rowId)) {
+              setAdd(linkedRows, rowId);
+              rowId = mapGet(remoteRows, rowId);
+            }
+          }
+          if (skipCache) {
+            return linkedRows;
+          }
+          mapSet(linkedRowsCache, firstRowId, linkedRows);
+        }
+        return mapGet(linkedRowsCache, firstRowId);
+      },
+    );
+  const delLinkedRowIdsCache = (relationshipId, firstRowId) =>
+    ifNotUndefined(getRelationship(relationshipId), ([, , linkedRowsCache]) =>
+      mapSet(linkedRowsCache, firstRowId),
+    );
+  const setRelationshipDefinition = (
+    relationshipId,
+    localTableId,
+    remoteTableId,
+    getRemoteRowId2,
+  ) => {
+    mapSet(remoteTableIds, relationshipId, remoteTableId);
+    setDefinition(
+      relationshipId,
+      localTableId,
+      (change, changedRemoteRowIds) => {
+        const changedLocalRows = setNew();
+        const changedRemoteRows = setNew();
+        const changedLinkedRows = setNew();
+        const [localRows, remoteRows] = getRelationship(relationshipId);
+        collForEach(
+          changedRemoteRowIds,
+          ([oldRemoteRowId, newRemoteRowId], localRowId) => {
+            if (!isUndefined(oldRemoteRowId)) {
+              setAdd(changedRemoteRows, oldRemoteRowId);
+              ifNotUndefined(
+                mapGet(remoteRows, oldRemoteRowId),
+                (oldRemoteRow) => {
+                  collDel(oldRemoteRow, localRowId);
+                  if (collIsEmpty(oldRemoteRow)) {
+                    mapSet(remoteRows, oldRemoteRowId);
+                  }
+                },
+              );
+            }
+            if (!isUndefined(newRemoteRowId)) {
+              setAdd(changedRemoteRows, newRemoteRowId);
+              if (!collHas(remoteRows, newRemoteRowId)) {
+                mapSet(remoteRows, newRemoteRowId, setNew());
+              }
+              setAdd(mapGet(remoteRows, newRemoteRowId), localRowId);
+            }
+            setAdd(changedLocalRows, localRowId);
+            mapSet(localRows, localRowId, newRemoteRowId);
+            mapForEach(
+              mapGet(linkedRowIdsListeners, relationshipId),
+              (firstRowId) => {
+                if (
+                  collHas(
+                    getLinkedRowIdsCache(relationshipId, firstRowId),
+                    localRowId,
+                  )
+                ) {
+                  setAdd(changedLinkedRows, firstRowId);
+                }
+              },
+            );
+          },
+        );
+        change();
+        collForEach(changedLocalRows, (localRowId) =>
+          callListeners(remoteRowIdListeners, [relationshipId, localRowId]),
+        );
+        collForEach(changedRemoteRows, (remoteRowId) =>
+          callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),
+        );
+        collForEach(changedLinkedRows, (firstRowId) => {
+          delLinkedRowIdsCache(relationshipId, firstRowId);
+          callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);
+        });
+      },
+      getRowCellFunction(getRemoteRowId2),
+    );
+    return relationships;
+  };
+  const delRelationshipDefinition = (relationshipId) => {
+    mapSet(remoteTableIds, relationshipId);
+    delDefinition(relationshipId);
+    return relationships;
+  };
+  const getRemoteTableId = (relationshipId) =>
+    mapGet(remoteTableIds, relationshipId);
+  const getRemoteRowId = (relationshipId, localRowId) =>
+    mapGet(getRelationship(relationshipId)?.[0], localRowId);
+  const getLocalRowIds = (relationshipId, remoteRowId) =>
+    collValues(mapGet(getRelationship(relationshipId)?.[1], remoteRowId));
+  const getLinkedRowIds = (relationshipId, firstRowId) =>
+    isUndefined(getRelationship(relationshipId))
+      ? [firstRowId]
+      : collValues(getLinkedRowIdsCache(relationshipId, firstRowId, true));
+  const addRemoteRowIdListener = (relationshipId, localRowId, listener) =>
+    addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);
+  const addLocalRowIdsListener = (relationshipId, remoteRowId, listener) =>
+    addListener(listener, localRowIdsListeners, [relationshipId, remoteRowId]);
+  const addLinkedRowIdsListener = (relationshipId, firstRowId, listener) => {
+    getLinkedRowIdsCache(relationshipId, firstRowId);
+    return addListener(listener, linkedRowIdsListeners, [
+      relationshipId,
+      firstRowId,
+    ]);
+  };
+  const delListener = (listenerId) => {
+    delLinkedRowIdsCache(...delListenerImpl(listenerId));
+    return relationships;
+  };
+  const getListenerStats = () => ({
+    remoteRowId: collSize3(remoteRowIdListeners),
+    localRowIds: collSize3(localRowIdsListeners),
+    linkedRowIds: collSize3(linkedRowIdsListeners),
+  });
+  const relationships = {
+    setRelationshipDefinition,
+    delRelationshipDefinition,
+    getStore,
+    getRelationshipIds,
+    getLocalTableId,
+    getRemoteTableId,
+    getRemoteRowId,
+    getLocalRowIds,
+    getLinkedRowIds,
+    addRemoteRowIdListener,
+    addLocalRowIdsListener,
+    addLinkedRowIdsListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(relationships);
+});
+
+const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
+  const idsToDelete = arrayFilter(
+    mapKeys(map),
+    (id) => !objHas(toBeLikeObject, id),
+  );
+  arrayForEach(objIds(toBeLikeObject), (id) =>
+    setId(map, id, toBeLikeObject[id]),
+  );
+  arrayForEach(idsToDelete, (id) => delId(map, id));
+  return map;
+};
+const getCellType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+const validate = (obj, validateChild) => {
+  if (isUndefined(obj) || !isObject(obj) || objFrozen(obj)) {
+    return false;
+  }
+  objForEach(obj, (child, id) => {
+    if (!validateChild(child, id)) {
+      objDel(obj, id);
+    }
+  });
+  return !objIsEmpty(obj);
+};
+const idsChanged = (ids, id, added) =>
+  mapSet(ids, id, mapGet(ids, id) == -added ? void 0 : added);
+const createStore = () => {
+  let hasSchema;
+  let nextRowId = 0;
+  let transactions = 0;
+  const changedTableIds = mapNew();
+  const changedRowIds = mapNew();
+  const changedCellIds = mapNew();
+  const changedCells = mapNew();
+  const schemaMap = mapNew();
+  const schemaDefaultRows = mapNew();
+  const tablesMap = mapNew();
+  const tablesListeners = mapNewPair(setNew);
+  const tableIdsListeners = mapNewPair(setNew);
+  const tableListeners = mapNewPair();
+  const rowIdsListeners = mapNewPair();
+  const rowListeners = mapNewPair();
+  const cellIdsListeners = mapNewPair();
+  const cellListeners = mapNewPair();
+  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
+    getListenerFunctions(() => store);
+  const validateSchema = (schema) =>
+    validate(schema, (tableSchema) =>
+      validate(tableSchema, (cellSchema) => {
+        if (
+          !validate(cellSchema, (_child, id) => arrayHas([TYPE, DEFAULT], id))
+        ) {
+          return false;
+        }
+        const type = cellSchema[TYPE];
+        if (!isTypeStringOrBoolean(type) && type != NUMBER) {
+          return false;
+        }
+        if (getCellType(cellSchema[DEFAULT]) != type) {
+          objDel(cellSchema, DEFAULT);
+        }
+        return true;
+      }),
+    );
+  const validateTables = (tables) => validate(tables, validateTable);
+  const validateTable = (table, tableId) =>
+    (!hasSchema || collHas(schemaMap, tableId)) &&
+    validate(table, (row) => validateRow(tableId, row));
+  const validateRow = (tableId, row, skipDefaults) =>
+    validate(
+      skipDefaults ? row : addDefaultsToRow(row, tableId),
+      (cell, cellId) =>
+        ifNotUndefined(
+          getValidatedCell(tableId, cellId, cell),
+          (validCell) => {
+            row[cellId] = validCell;
+            return true;
+          },
+          () => false,
+        ),
+    );
+  const getValidatedCell = (tableId, cellId, cell) =>
+    hasSchema
+      ? ifNotUndefined(
+          mapGet(mapGet(schemaMap, tableId), cellId),
+          (cellSchema) =>
+            getCellType(cell) != cellSchema[TYPE] ? cellSchema[DEFAULT] : cell,
+        )
+      : isUndefined(getCellType(cell))
+      ? void 0
+      : cell;
+  const addDefaultsToRow = (row, tableId) => {
+    ifNotUndefined(mapGet(schemaDefaultRows, tableId), (defaultRow) =>
+      objForEach(defaultRow, (cell, cellId) => {
+        if (!objHas(row, cellId)) {
+          row[cellId] = cell;
+        }
+      }),
+    );
+    return row;
+  };
+  const setValidSchema = (schema) =>
+    transformMap(
+      schemaMap,
+      schema,
+      (_schema, tableId, tableSchema) => {
+        const defaultRow = {};
+        transformMap(
+          mapEnsure(schemaMap, tableId, mapNew()),
+          tableSchema,
+          (tableSchemaMap, cellId, cellSchema) => {
+            mapSet(tableSchemaMap, cellId, cellSchema);
+            ifNotUndefined(
+              cellSchema[DEFAULT],
+              (def) => (defaultRow[cellId] = def),
+            );
+          },
+        );
+        mapSet(schemaDefaultRows, tableId, defaultRow);
+      },
+      (_schema, tableId) => {
+        mapSet(schemaMap, tableId);
+        mapSet(schemaDefaultRows, tableId);
+      },
+    );
+  const setValidTables = (tables) =>
+    transformMap(
+      tablesMap,
+      tables,
+      (_tables, tableId, table) => setValidTable(tableId, table),
+      (_tables, tableId) => delValidTable(tableId),
+    );
+  const setValidTable = (tableId, table) =>
+    transformMap(
+      mapEnsure(tablesMap, tableId, mapNew(), () =>
+        tableIdsChanged(tableId, 1),
+      ),
+      table,
+      (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),
+      (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),
+    );
+  const setValidRow = (tableId, tableMap, rowId, newRow, forceDel) =>
+    transformMap(
+      mapEnsure(tableMap, rowId, mapNew(), () =>
+        rowIdsChanged(tableId, rowId, 1),
+      ),
+      newRow,
+      (rowMap, cellId, cell) =>
+        setValidCell(tableId, rowId, rowMap, cellId, cell),
+      (rowMap, cellId) =>
+        delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+    );
+  const setValidCell = (tableId, rowId, rowMap, cellId, newCell) => {
+    if (!collHas(rowMap, cellId)) {
+      cellIdsChanged(tableId, rowId, cellId, 1);
+    }
+    const oldCell = mapGet(rowMap, cellId);
+    if (newCell !== oldCell) {
+      cellChanged(tableId, rowId, cellId, oldCell);
+      mapSet(rowMap, cellId, newCell);
+    }
+  };
+  const setValidRowTransaction = (tableId, rowId, row) =>
+    transaction(() =>
+      setValidRow(tableId, getOrCreateTable(tableId), rowId, row),
+    );
+  const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>
+    ifNotUndefined(
+      mapGet(tableMap, rowId),
+      (rowMap) => setValidCell(tableId, rowId, rowMap, cellId, validCell),
+      () =>
+        setValidRow(
+          tableId,
+          tableMap,
+          rowId,
+          addDefaultsToRow({[cellId]: validCell}, tableId),
+        ),
+    );
+  const getNewRowId = (tableMap) => {
+    const rowId = '' + nextRowId++;
+    if (!collHas(tableMap, rowId)) {
+      return rowId;
+    }
+    return getNewRowId(tableMap);
+  };
+  const getOrCreateTable = (tableId) =>
+    mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});
+  const delValidTable = (tableId) => setValidTable(tableId, {});
+  const delValidRow = (tableId, tableMap, rowId) =>
+    setValidRow(tableId, tableMap, rowId, {}, true);
+  const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {
+    const defaultCell = mapGet(schemaDefaultRows, tableId)?.[cellId];
+    if (!isUndefined(defaultCell) && !forceDel) {
+      return setValidCell(tableId, rowId, row, cellId, defaultCell);
+    }
+    const delCell2 = (cellId2) => {
+      cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));
+      cellIdsChanged(tableId, rowId, cellId2, -1);
+      mapSet(row, cellId2);
+    };
+    isUndefined(defaultCell) ? delCell2(cellId) : mapForEach(row, delCell2);
+    if (collIsEmpty(row)) {
+      rowIdsChanged(tableId, rowId, -1);
+      if (collIsEmpty(mapSet(table, rowId))) {
+        tableIdsChanged(tableId, -1);
+        mapSet(tablesMap, tableId);
+      }
+    }
+  };
+  const tableIdsChanged = (tableId, added) =>
+    idsChanged(changedTableIds, tableId, added);
+  const rowIdsChanged = (tableId, rowId, added) =>
+    idsChanged(mapEnsure(changedRowIds, tableId, mapNew()), rowId, added);
+  const cellIdsChanged = (tableId, rowId, cellId, added) =>
+    idsChanged(
+      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew()), rowId, mapNew()),
+      cellId,
+      added,
+    );
+  const cellChanged = (tableId, rowId, cellId, oldCell) =>
+    mapEnsure(
+      mapEnsure(mapEnsure(changedCells, tableId, mapNew()), rowId, mapNew()),
+      cellId,
+      oldCell,
+    );
+  const getCellChange = (tableId, rowId, cellId) => {
+    const changedRow = mapGet(mapGet(changedCells, tableId), rowId);
+    const newCell = getCell(tableId, rowId, cellId);
+    return collHas(changedRow, cellId)
+      ? [true, mapGet(changedRow, cellId), newCell]
+      : [false, newCell, newCell];
+  };
+  const callListenersForChanges = (mutator) => {
+    const emptyIdListeners =
+      collIsEmpty(cellIdsListeners[mutator]) &&
+      collIsEmpty(rowIdsListeners[mutator]) &&
+      collIsEmpty(tableIdsListeners[mutator]);
+    const emptyOtherListeners =
+      collIsEmpty(cellListeners[mutator]) &&
+      collIsEmpty(rowListeners[mutator]) &&
+      collIsEmpty(tableListeners[mutator]) &&
+      collIsEmpty(tablesListeners[mutator]);
+    if (emptyIdListeners && emptyOtherListeners) {
+      return;
+    }
+    const changes = mutator
+      ? [
+          mapClone(changedTableIds),
+          mapClone(changedRowIds, mapClone),
+          mapClone(changedCellIds, (table) => mapClone(table, mapClone)),
+          mapClone(changedCells, (table) => mapClone(table, mapClone)),
+        ]
+      : [changedTableIds, changedRowIds, changedCellIds, changedCells];
+    if (!emptyIdListeners) {
+      collForEach(changes[2], (rowCellIds, tableId) =>
+        collForEach(rowCellIds, (changedIds, rowId) => {
+          if (!collIsEmpty(changedIds)) {
+            callListeners(cellIdsListeners[mutator], [tableId, rowId]);
+          }
+        }),
+      );
+      collForEach(changes[1], (changedIds, tableId) => {
+        if (!collIsEmpty(changedIds)) {
+          callListeners(rowIdsListeners[mutator], [tableId]);
+        }
+      });
+      if (!collIsEmpty(changes[0])) {
+        callListeners(tableIdsListeners[mutator]);
+      }
+    }
+    if (!emptyOtherListeners) {
+      let tablesChanged;
+      collForEach(changes[3], (rows, tableId) => {
+        let tableChanged;
+        collForEach(rows, (cells, rowId) => {
+          let rowChanged;
+          collForEach(cells, (oldCell, cellId) => {
+            const newCell = getCell(tableId, rowId, cellId);
+            if (newCell !== oldCell) {
+              callListeners(
+                cellListeners[mutator],
+                [tableId, rowId, cellId],
+                newCell,
+                oldCell,
+                getCellChange,
+              );
+              tablesChanged = tableChanged = rowChanged = 1;
+            }
+          });
+          if (rowChanged) {
+            callListeners(
+              rowListeners[mutator],
+              [tableId, rowId],
+              getCellChange,
+            );
+          }
+        });
+        if (tableChanged) {
+          callListeners(tableListeners[mutator], [tableId], getCellChange);
+        }
+      });
+      if (tablesChanged) {
+        callListeners(tablesListeners[mutator], [], getCellChange);
+      }
+    }
+  };
+  const getTables = () =>
+    mapToObj(tablesMap, (tableMap) => mapToObj(tableMap, mapToObj));
+  const getTableIds = () => mapKeys(tablesMap);
+  const getTable = (tableId) => mapToObj(mapGet(tablesMap, tableId), mapToObj);
+  const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, tableId));
+  const getRow = (tableId, rowId) =>
+    mapToObj(mapGet(mapGet(tablesMap, tableId), rowId));
+  const getCellIds = (tableId, rowId) =>
+    mapKeys(mapGet(mapGet(tablesMap, tableId), rowId));
+  const getCell = (tableId, rowId, cellId) =>
+    mapGet(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const hasTable = (tableId) => collHas(tablesMap, tableId);
+  const hasRow = (tableId, rowId) => collHas(mapGet(tablesMap, tableId), rowId);
+  const hasCell = (tableId, rowId, cellId) =>
+    collHas(mapGet(mapGet(tablesMap, tableId), rowId), cellId);
+  const getJson = () => jsonString(tablesMap);
+  const getSchemaJson = () => jsonString(schemaMap);
+  const setTables = (tables) => {
+    if (validateTables(tables)) {
+      transaction(() => setValidTables(tables));
+    }
+    return store;
+  };
+  const setTable = (tableId, table) => {
+    if (validateTable(table, tableId)) {
+      transaction(() => setValidTable(tableId, table));
+    }
+    return store;
+  };
+  const setRow = (tableId, rowId, row) => {
+    if (validateRow(tableId, row)) {
+      setValidRowTransaction(tableId, rowId, row);
+    }
+    return store;
+  };
+  const addRow = (tableId, row) => {
+    let rowId = void 0;
+    if (validateRow(tableId, row)) {
+      rowId = getNewRowId(mapGet(tablesMap, tableId));
+      setValidRowTransaction(tableId, rowId, row);
+    }
+    return rowId;
+  };
+  const setPartialRow = (tableId, rowId, partialRow) => {
+    if (validateRow(tableId, partialRow, 1)) {
+      transaction(() => {
+        const table = getOrCreateTable(tableId);
+        objForEach(partialRow, (cell, cellId) =>
+          setCellIntoDefaultRow(tableId, table, rowId, cellId, cell),
+        );
+      });
+    }
+    return store;
+  };
+  const setCell = (tableId, rowId, cellId, cell) => {
+    ifNotUndefined(
+      getValidatedCell(
+        tableId,
+        cellId,
+        isFunction(cell) ? cell(getCell(tableId, rowId, cellId)) : cell,
+      ),
+      (validCell) =>
+        transaction(() =>
+          setCellIntoDefaultRow(
+            tableId,
+            getOrCreateTable(tableId),
+            rowId,
+            cellId,
+            validCell,
+          ),
+        ),
+    );
+    return store;
+  };
+  const setJson = (json) => {
+    try {
+      json === EMPTY_OBJECT ? delTables() : setTables(jsonParse(json));
+    } catch {}
+    return store;
+  };
+  const setSchema = (schema) => {
+    if ((hasSchema = validateSchema(schema))) {
+      setValidSchema(schema);
+      if (!collIsEmpty(tablesMap)) {
+        const tables = getTables();
+        delTables();
+        setTables(tables);
+      }
+    }
+    return store;
+  };
+  const delTables = () => {
+    transaction(() => setValidTables({}));
+    return store;
+  };
+  const delTable = (tableId) => {
+    if (collHas(tablesMap, tableId)) {
+      transaction(() => delValidTable(tableId));
+    }
+    return store;
+  };
+  const delRow = (tableId, rowId) => {
+    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) => {
+      if (collHas(tableMap, rowId)) {
+        transaction(() => delValidRow(tableId, tableMap, rowId));
+      }
+    });
+    return store;
+  };
+  const delCell = (tableId, rowId, cellId, forceDel) => {
+    ifNotUndefined(mapGet(tablesMap, tableId), (tableMap) =>
+      ifNotUndefined(mapGet(tableMap, rowId), (rowMap) => {
+        if (collHas(rowMap, cellId)) {
+          transaction(() =>
+            delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),
+          );
+        }
+      }),
+    );
+    return store;
+  };
+  const delSchema = () => {
+    setValidSchema({});
+    hasSchema = false;
+    return store;
+  };
+  const transaction = (actions) => {
+    if (transactions == -1) {
+      return;
+    }
+    transactions++;
+    const result = actions();
+    transactions--;
+    if (transactions == 0) {
+      transactions = 1;
+      callListenersForChanges(1);
+      transactions = -1;
+      callListenersForChanges(0);
+      transactions = 0;
+      arrayForEach(
+        [changedCells, changedTableIds, changedRowIds, changedCellIds],
+        collClear,
+      );
+    }
+    return result;
+  };
+  const forEachTable = (tableCallback) =>
+    collForEach(tablesMap, (tableMap, tableId) =>
+      tableCallback(tableId, (rowCallback) =>
+        collForEach(tableMap, (rowMap, rowId) =>
+          rowCallback(rowId, (cellCallback) =>
+            mapForEach(rowMap, cellCallback),
+          ),
+        ),
+      ),
+    );
+  const forEachRow = (tableId, rowCallback) =>
+    collForEach(mapGet(tablesMap, tableId), (rowMap, rowId) =>
+      rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),
+    );
+  const forEachCell = (tableId, rowId, cellCallback) =>
+    mapForEach(mapGet(mapGet(tablesMap, tableId), rowId), cellCallback);
+  const addTablesListener = (listener, mutator) =>
+    addListener(listener, tablesListeners[mutator ? 1 : 0]);
+  const addTableIdsListener = (listener, mutator) =>
+    addListener(listener, tableIdsListeners[mutator ? 1 : 0]);
+  const addTableListener = (tableId, listener, mutator) =>
+    addListener(listener, tableListeners[mutator ? 1 : 0], [tableId]);
+  const addRowIdsListener = (tableId, listener, mutator) =>
+    addListener(listener, rowIdsListeners[mutator ? 1 : 0], [tableId]);
+  const addRowListener = (tableId, rowId, listener, mutator) =>
+    addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
+  const addCellIdsListener = (tableId, rowId, listener, mutator) =>
+    addListener(listener, cellIdsListeners[mutator ? 1 : 0], [tableId, rowId]);
+  const addCellListener = (tableId, rowId, cellId, listener, mutator) =>
+    addListener(listener, cellListeners[mutator ? 1 : 0], [
+      tableId,
+      rowId,
+      cellId,
+    ]);
+  const callListener = (listenerId) => {
+    callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
+      isUndefined(ids[2]) ? [] : Array(2).fill(getCell(...ids)),
+    );
+    return store;
+  };
+  const delListener = (listenerId) => {
+    delListenerImpl(listenerId);
+    return store;
+  };
+  const getListenerStats = () => ({
+    tables: collPairSize(tablesListeners),
+    tableIds: collPairSize(tableIdsListeners),
+    table: collPairSize(tableListeners, collSize2),
+    rowIds: collPairSize(rowIdsListeners, collSize2),
+    row: collPairSize(rowListeners, collSize3),
+    cellIds: collPairSize(cellIdsListeners, collSize3),
+    cell: collPairSize(cellListeners, collSize4),
+  });
+  const store = {
+    getTables,
+    getTableIds,
+    getTable,
+    getRowIds,
+    getRow,
+    getCellIds,
+    getCell,
+    hasTable,
+    hasRow,
+    hasCell,
+    getJson,
+    getSchemaJson,
+    setTables,
+    setTable,
+    setRow,
+    addRow,
+    setPartialRow,
+    setCell,
+    setJson,
+    setSchema,
+    delTables,
+    delTable,
+    delRow,
+    delCell,
+    delSchema,
+    transaction,
+    forEachTable,
+    forEachRow,
+    forEachCell,
+    addTablesListener,
+    addTableIdsListener,
+    addTableListener,
+    addRowIdsListener,
+    addRowListener,
+    addCellIdsListener,
+    addCellListener,
+    callListener,
+    delListener,
+    getListenerStats,
+  };
+  return objFreeze(store);
+};
+
+export {
+  createCheckpoints,
+  createCustomPersister,
+  createFilePersister,
+  createIndexes,
+  createLocalPersister,
+  createMetrics,
+  createRelationships,
+  createRemotePersister,
+  createSessionPersister,
+  createStore,
+  defaultSorter,
+};