{"version":3,"sources":["jsdelivr-header.js","/npm/tinybase@7.3.5/index.js"],"names":[],"mappings":"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","file":"/npm/tinybase@7.3.5/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/tinybase@7.3.5/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","const getTypeOf = (thing) => typeof thing;\nconst EMPTY_STRING = '';\nconst STRING = getTypeOf(EMPTY_STRING);\nconst BOOLEAN = getTypeOf(true);\nconst NUMBER = getTypeOf(0);\nconst FUNCTION = getTypeOf(getTypeOf);\nconst TYPE = 'type';\nconst DEFAULT = 'default';\nconst ALLOW_NULL = 'allowNull';\nconst NULL = 'null';\nconst SUM = 'sum';\nconst AVG = 'avg';\nconst MIN = 'min';\nconst MAX = 'max';\nconst LISTENER = 'Listener';\nconst RESULT = 'Result';\nconst GET = 'get';\nconst SET = 'set';\nconst ADD = 'add';\nconst DEL = 'del';\nconst HAS = 'Has';\nconst IDS = 'Ids';\nconst TABLE = 'Table';\nconst TABLES = TABLE + 's';\nconst TABLE_IDS = TABLE + IDS;\nconst ROW = 'Row';\nconst ROW_COUNT = ROW + 'Count';\nconst ROW_IDS = ROW + IDS;\nconst SORTED_ROW_IDS = 'Sorted' + ROW + IDS;\nconst CELL = 'Cell';\nconst CELL_IDS = CELL + IDS;\nconst VALUE = 'Value';\nconst VALUES = VALUE + 's';\nconst VALUE_IDS = VALUE + IDS;\nconst TRANSACTION = 'Transaction';\nconst id = (key) => EMPTY_STRING + key;\nconst strStartsWith = (str, prefix) => str.startsWith(prefix);\nconst strEndsWith = (str, suffix) => str.endsWith(suffix);\nconst strSplit = (str, separator = EMPTY_STRING, limit) =>\n  str.split(separator, limit);\n\nconst getIfNotFunction = (predicate) => (value, then, otherwise) =>\n  predicate(value) ? otherwise?.() : then(value);\nconst GLOBAL = globalThis;\nconst math = Math;\nconst mathMax = math.max;\nconst mathMin = math.min;\nconst mathFloor = math.floor;\nconst isFiniteNumber = isFinite;\nconst isInstanceOf = (thing, cls) => thing instanceof cls;\nconst isNullish = (thing) => thing == null;\nconst isUndefined = (thing) => thing === void 0;\nconst isNull = (thing) => thing === null;\nconst isTrue = (thing) => thing === true;\nconst isFalse = (thing) => thing === false;\nconst ifNotNullish = getIfNotFunction(isNullish);\nconst ifNotUndefined = getIfNotFunction(isUndefined);\nconst isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;\nconst isString = (thing) => getTypeOf(thing) == STRING;\nconst isFunction = (thing) => getTypeOf(thing) == FUNCTION;\nconst isArray = (thing) => Array.isArray(thing);\nconst slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);\nconst size = (arrayOrString) => arrayOrString.length;\nconst test = (regex, subject) => regex.test(subject);\nconst getUndefined = () => void 0;\nconst noop = () => {};\nconst tryCatch = async (action, then1, then2) => {\n  try {\n    return await action();\n  } catch (error) {\n    /* istanbul ignore next */\n    then1?.(error);\n  }\n};\n\nconst arrayHas = (array, value) => array.includes(value);\nconst arrayEvery = (array, cb) => array.every(cb);\nconst arrayIsEqual = (array1, array2) =>\n  size(array1) === size(array2) &&\n  arrayEvery(array1, (value1, index) => array2[index] === value1);\nconst arrayOrValueEqual = (value1, value2) =>\n  isArray(value1) && isArray(value2)\n    ? arrayIsEqual(value1, value2)\n    : value1 === value2;\nconst arrayIsSorted = (array, sorter) =>\n  arrayEvery(\n    array,\n    (value, index) => index == 0 || sorter(array[index - 1], value) <= 0,\n  );\nconst arraySort = (array, sorter) => array.sort(sorter);\nconst arrayForEach = (array, cb) => array.forEach(cb);\nconst arrayMap = (array, cb) => array.map(cb);\nconst arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);\nconst arrayIsEmpty = (array) => size(array) == 0;\nconst arrayReduce = (array, cb, initial) => array.reduce(cb, initial);\nconst arrayClear = (array, to) => array.splice(0, to);\nconst arrayPush = (array, ...values) => array.push(...values);\nconst arrayPop = (array) => array.pop();\nconst arrayUnshift = (array, ...values) => array.unshift(...values);\nconst arrayShift = (array) => array.shift();\n\nconst getCellOrValueType = (cellOrValue) => {\n  if (isNull(cellOrValue)) {\n    return NULL;\n  }\n  const type = getTypeOf(cellOrValue);\n  return isTypeStringOrBoolean(type) ||\n    (type == NUMBER && isFiniteNumber(cellOrValue))\n    ? type\n    : void 0;\n};\nconst isCellOrValueOrUndefined = (cellOrValue) =>\n  isUndefined(cellOrValue) || !isUndefined(getCellOrValueType(cellOrValue));\nconst setOrDelCell = (store, tableId, rowId, cellId, cell) =>\n  isUndefined(cell)\n    ? store.delCell(tableId, rowId, cellId, true)\n    : store.setCell(tableId, rowId, cellId, cell);\nconst setOrDelValue = (store, valueId, value) =>\n  isUndefined(value) ? store.delValue(valueId) : store.setValue(valueId, value);\n\nconst collSizeN = (collSizer) => (coll) =>\n  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);\nconst collSize = (coll) => coll?.size ?? 0;\nconst collSize2 = collSizeN(collSize);\nconst collSize3 = collSizeN(collSize2);\nconst collSize4 = collSizeN(collSize3);\nconst collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;\nconst collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;\nconst collValues = (coll) => [...(coll?.values() ?? [])];\nconst collClear = (coll) => coll.clear();\nconst collForEach = (coll, cb) => coll?.forEach(cb);\nconst collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);\n\nconst object = Object;\nconst getPrototypeOf = (obj) => object.getPrototypeOf(obj);\nconst objFrozen = object.isFrozen;\nconst objEntries = object.entries;\nconst isObject = (obj) =>\n  !isNullish(obj) &&\n  ifNotNullish(\n    getPrototypeOf(obj),\n    (objPrototype) =>\n      objPrototype == object.prototype ||\n      isNullish(getPrototypeOf(objPrototype)),\n\n    /* istanbul ignore next */\n    () => true,\n  );\nconst objIds = object.keys;\nconst objFreeze = object.freeze;\nconst objNew = (entries = []) => object.fromEntries(entries);\nconst objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);\nconst objHas = (obj, id) => id in obj;\nconst objDel = (obj, id) => {\n  delete obj[id];\n  return obj;\n};\nconst objToMap = (obj) => new Map(objEntries(obj));\nconst objForEach = (obj, cb) =>\n  arrayForEach(objEntries(obj), ([id, value]) => cb(value, id));\nconst objToArray = (obj, cb) =>\n  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));\nconst objMap = (obj, cb) =>\n  objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));\nconst objSize = (obj) => size(objIds(obj));\nconst objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;\n\n/* istanbul ignore next */\nconst objIsEqual = (\n  obj1,\n  obj2,\n  isEqual = (value1, value2) => value1 === value2,\n) => {\n  const entries1 = objEntries(obj1);\n  return (\n    size(entries1) === objSize(obj2) &&\n    arrayEvery(entries1, ([index, value1]) =>\n      isObject(value1)\n        ? /* istanbul ignore next */\n          isObject(obj2[index])\n          ? objIsEqual(obj2[index], value1)\n          : false\n        : isEqual(value1, obj2[index]),\n    )\n  );\n};\nconst objEnsure = (obj, id, getDefaultValue) => {\n  if (!objHas(obj, id)) {\n    obj[id] = getDefaultValue();\n  }\n  return obj[id];\n};\nconst objValidate = (obj, validateChild, onInvalidObj, emptyIsValid = 0) => {\n  if (\n    isNullish(obj) ||\n    !isObject(obj) ||\n    (!emptyIsValid && objIsEmpty(obj)) ||\n    objFrozen(obj)\n  ) {\n    onInvalidObj?.();\n    return false;\n  }\n  objForEach(obj, (child, id) => {\n    if (!validateChild(child, id)) {\n      objDel(obj, id);\n    }\n  });\n  return emptyIsValid ? true : !objIsEmpty(obj);\n};\n\nconst map = Map;\nconst mapNew = (entries) => new map(entries);\nconst mapKeys = (map2) => [...(map2?.keys() ?? [])];\nconst mapGet = (map2, key) => map2?.get(key);\nconst mapForEach = (map2, cb) =>\n  collForEach(map2, (value, key) => cb(key, value));\nconst mapMap = (coll, cb) =>\n  arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));\nconst mapSet = (map2, key, value) =>\n  isUndefined(value) ? (collDel(map2, key), map2) : map2?.set(key, value);\nconst mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {\n  if (!collHas(map2, key)) {\n    mapSet(map2, key, getDefaultValue());\n  } else {\n    hadExistingValue?.(mapGet(map2, key));\n  }\n  return mapGet(map2, key);\n};\nconst mapMatch = (map2, obj, set, del = mapSet) => {\n  objMap(obj, (value, id) => set(map2, id, value));\n  mapForEach(map2, (id) => (objHas(obj, id) ? 0 : del(map2, id)));\n  return map2;\n};\nconst mapToObj = (map2, valueMapper, excludeMapValue, excludeObjValue) => {\n  const obj = {};\n  collForEach(map2, (mapValue, id) => {\n    if (!excludeMapValue?.(mapValue, id)) {\n      const objValue = valueMapper ? valueMapper(mapValue, id) : mapValue;\n      if (!excludeObjValue?.(objValue)) {\n        obj[id] = objValue;\n      }\n    }\n  });\n  return obj;\n};\nconst mapToObj2 = (map2, valueMapper, excludeMapValue) =>\n  mapToObj(\n    map2,\n    (childMap) => mapToObj(childMap, valueMapper, excludeMapValue),\n    collIsEmpty,\n    objIsEmpty,\n  );\nconst mapToObj3 = (map2, valueMapper, excludeMapValue) =>\n  mapToObj(\n    map2,\n    (childMap) => mapToObj2(childMap, valueMapper, excludeMapValue),\n    collIsEmpty,\n    objIsEmpty,\n  );\nconst mapClone = (map2, mapValue) => {\n  const map22 = mapNew();\n  collForEach(map2, (value, key) => map22.set(key, mapValue?.(value) ?? value));\n  return map22;\n};\nconst mapClone2 = (map2) => mapClone(map2, mapClone);\nconst mapClone3 = (map2) => mapClone(map2, mapClone2);\nconst visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>\n  ifNotUndefined(\n    (ensureLeaf ? mapEnsure : mapGet)(\n      node,\n      path[p],\n      p > size(path) - 2 ? ensureLeaf : mapNew,\n    ),\n    (nodeOrLeaf) => {\n      if (p > size(path) - 2) {\n        if (pruneLeaf?.(nodeOrLeaf)) {\n          mapSet(node, path[p]);\n        }\n        return nodeOrLeaf;\n      }\n      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);\n      if (collIsEmpty(nodeOrLeaf)) {\n        mapSet(node, path[p]);\n      }\n      return leaf;\n    },\n  );\n\nconst setNew = (entryOrEntries) =>\n  new Set(\n    isArray(entryOrEntries) || isUndefined(entryOrEntries)\n      ? entryOrEntries\n      : [entryOrEntries],\n  );\nconst setAdd = (set, value) => set?.add(value);\n\nconst getDefinableFunctions = (\n  store,\n  getDefaultThing,\n  validateRowValue,\n  addListener,\n  callListeners,\n) => {\n  const hasRow = store.hasRow;\n  const tableIds = mapNew();\n  const things = mapNew();\n  const thingIdListeners = mapNew();\n  const allRowValues = mapNew();\n  const allSortKeys = mapNew();\n  const storeListenerIds = mapNew();\n  const getStore = () => store;\n  const getThingIds = () => mapKeys(tableIds);\n  const forEachThing = (cb) => mapForEach(things, cb);\n  const hasThing = (id) => collHas(things, id);\n  const getTableId = (id) => mapGet(tableIds, id);\n  const getThing = (id) => mapGet(things, id);\n  const setThing = (id, thing) => mapSet(things, id, thing);\n  const addStoreListeners = (id, andCall, ...listenerIds) => {\n    const set = mapEnsure(storeListenerIds, id, setNew);\n    arrayForEach(\n      listenerIds,\n      (listenerId) =>\n        setAdd(set, listenerId) && andCall && store.callListener(listenerId),\n    );\n    return listenerIds;\n  };\n  const delStoreListeners = (id, ...listenerIds) =>\n    ifNotUndefined(mapGet(storeListenerIds, id), (allListenerIds) => {\n      arrayForEach(\n        arrayIsEmpty(listenerIds) ? collValues(allListenerIds) : listenerIds,\n        (listenerId) => {\n          store.delListener(listenerId);\n          collDel(allListenerIds, listenerId);\n        },\n      );\n      if (collIsEmpty(allListenerIds)) {\n        mapSet(storeListenerIds, id);\n      }\n    });\n  const setDefinition = (id, tableId) => {\n    mapSet(tableIds, id, tableId);\n    if (!collHas(things, id)) {\n      mapSet(things, id, getDefaultThing());\n      mapSet(allRowValues, id, mapNew());\n      mapSet(allSortKeys, id, mapNew());\n      callListeners(thingIdListeners);\n    }\n  };\n  const setDefinitionAndListen = (\n    id,\n    tableId,\n    onChanged,\n    getRowValue,\n    getSortKey,\n  ) => {\n    setDefinition(id, tableId);\n    const changedRowValues = mapNew();\n    const changedSortKeys = mapNew();\n    const rowValues = mapGet(allRowValues, id);\n    const sortKeys = mapGet(allSortKeys, id);\n    const processRow = (rowId) => {\n      const getCell = (cellId) => store.getCell(tableId, rowId, cellId);\n      const oldRowValue = mapGet(rowValues, rowId);\n      const newRowValue = hasRow(tableId, rowId)\n        ? validateRowValue(getRowValue(getCell, rowId))\n        : void 0;\n      if (\n        !(\n          oldRowValue === newRowValue ||\n          (isArray(oldRowValue) &&\n            isArray(newRowValue) &&\n            arrayIsEqual(oldRowValue, newRowValue))\n        )\n      ) {\n        mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);\n      }\n      if (!isUndefined(getSortKey)) {\n        const oldSortKey = mapGet(sortKeys, rowId);\n        const newSortKey = hasRow(tableId, rowId)\n          ? getSortKey(getCell, rowId)\n          : void 0;\n        if (oldSortKey != newSortKey) {\n          mapSet(changedSortKeys, rowId, newSortKey);\n        }\n      }\n    };\n    const processTable = (force) => {\n      onChanged(\n        () => {\n          collForEach(changedRowValues, ([, newRowValue], rowId) =>\n            mapSet(rowValues, rowId, newRowValue),\n          );\n          collForEach(changedSortKeys, (newSortKey, rowId) =>\n            mapSet(sortKeys, rowId, newSortKey),\n          );\n        },\n        changedRowValues,\n        changedSortKeys,\n        rowValues,\n        sortKeys,\n        force,\n      );\n      collClear(changedRowValues);\n      collClear(changedSortKeys);\n    };\n    mapForEach(rowValues, processRow);\n    if (store.hasTable(tableId)) {\n      arrayForEach(store.getRowIds(tableId), (rowId) => {\n        if (!collHas(rowValues, rowId)) {\n          processRow(rowId);\n        }\n      });\n    }\n    processTable(true);\n    delStoreListeners(id);\n    addStoreListeners(\n      id,\n      0,\n      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>\n        processRow(rowId),\n      ),\n      store.addTableListener(tableId, () => processTable()),\n    );\n  };\n  const delDefinition = (id) => {\n    mapSet(tableIds, id);\n    mapSet(things, id);\n    mapSet(allRowValues, id);\n    mapSet(allSortKeys, id);\n    delStoreListeners(id);\n    callListeners(thingIdListeners);\n  };\n  const addThingIdsListener = (listener) =>\n    addListener(listener, thingIdListeners);\n  const destroy = () => mapForEach(storeListenerIds, delDefinition);\n  return [\n    getStore,\n    getThingIds,\n    forEachThing,\n    hasThing,\n    getTableId,\n    getThing,\n    setThing,\n    setDefinition,\n    setDefinitionAndListen,\n    delDefinition,\n    addThingIdsListener,\n    destroy,\n    addStoreListeners,\n    delStoreListeners,\n  ];\n};\nconst getRowCellFunction = (getRowCell, defaultCellValue) =>\n  isString(getRowCell)\n    ? (getCell) => getCell(getRowCell)\n    : (getRowCell ?? (() => defaultCellValue ?? EMPTY_STRING));\nconst getCreateFunction = (getFunction, initFunction) => {\n  const thingsByStore = /* @__PURE__ */ new WeakMap();\n  return (store) => {\n    if (!thingsByStore.has(store)) {\n      thingsByStore.set(store, getFunction(store));\n    }\n    const thing = thingsByStore.get(store);\n    initFunction?.(thing);\n    return thing;\n  };\n};\n\nconst INTEGER = /^\\d+$/;\nconst getPoolFunctions = () => {\n  const pool = [];\n  let nextId = 0;\n  return [\n    (reuse) => (reuse ? arrayShift(pool) : null) ?? EMPTY_STRING + nextId++,\n    (id) => {\n      if (test(INTEGER, id) && size(pool) < 1e3) {\n        arrayPush(pool, id);\n      }\n    },\n  ];\n};\n\nconst getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {\n  const leaves = [];\n  const deep = (node, p) =>\n    p == size(path)\n      ? arrayPush(leaves, node)\n      : isNull(path[p])\n        ? collForEach(node, (node2) => deep(node2, p + 1))\n        : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));\n  deep(deepIdSet, 0);\n  return leaves;\n};\nconst getListenerFunctions = (getThing) => {\n  let thing;\n  const [getId, releaseId] = getPoolFunctions();\n  const allListeners = mapNew();\n  const addListener = (\n    listener,\n    idSetNode,\n    path,\n    pathGetters = [],\n    extraArgsGetter = () => [],\n  ) => {\n    thing ??= getThing();\n    const id = getId(1);\n    mapSet(allListeners, id, [\n      listener,\n      idSetNode,\n      path,\n      pathGetters,\n      extraArgsGetter,\n    ]);\n    setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);\n    return id;\n  };\n  const callListeners = (idSetNode, ids, ...extraArgs) =>\n    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>\n      collForEach(set, (id) =>\n        mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),\n      ),\n    );\n  const delListener = (id) =>\n    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {\n      visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {\n        collDel(idSet, id);\n        return collIsEmpty(idSet) ? 1 : 0;\n      });\n      mapSet(allListeners, id);\n      releaseId(id);\n      return idOrNulls;\n    });\n  const callListener = (id) =>\n    ifNotUndefined(\n      mapGet(allListeners, id),\n      ([listener, , path = [], pathGetters, extraArgsGetter]) => {\n        const callWithIds = (...ids) => {\n          const index = size(ids);\n          if (index == size(path)) {\n            listener(thing, ...ids, ...extraArgsGetter(ids));\n          } else if (isNull(path[index])) {\n            arrayForEach(pathGetters[index]?.(...ids) ?? [], (id2) =>\n              callWithIds(...ids, id2),\n            );\n          } else {\n            callWithIds(...ids, path[index]);\n          }\n        };\n        callWithIds();\n      },\n    );\n  return [addListener, callListeners, delListener, callListener];\n};\n\nconst createCheckpoints = getCreateFunction(\n  (store) => {\n    let backwardIdsSize = 100;\n    let currentId;\n    let cellsDelta = mapNew();\n    let valuesDelta = mapNew();\n    let listening = 1;\n    let nextCheckpointId;\n    let checkpointsChanged;\n    const checkpointIdsListeners = mapNew();\n    const checkpointListeners = mapNew();\n    const [addListener, callListeners, delListenerImpl] = getListenerFunctions(\n      () => checkpoints,\n    );\n    const deltas = mapNew();\n    const labels = mapNew();\n    const backwardIds = [];\n    const forwardIds = [];\n    const updateStore = (oldOrNew, checkpointId) => {\n      listening = 0;\n      store.transaction(() => {\n        const [cellsDelta2, valuesDelta2] = mapGet(deltas, checkpointId);\n        collForEach(cellsDelta2, (table, tableId) =>\n          collForEach(table, (row, rowId) =>\n            collForEach(row, (oldNew, cellId) =>\n              setOrDelCell(store, tableId, rowId, cellId, oldNew[oldOrNew]),\n            ),\n          ),\n        );\n        collForEach(valuesDelta2, (oldNew, valueId) =>\n          setOrDelValue(store, valueId, oldNew[oldOrNew]),\n        );\n      });\n      listening = 1;\n    };\n    const clearCheckpointId = (checkpointId) => {\n      mapSet(deltas, checkpointId);\n      mapSet(labels, checkpointId);\n      callListeners(checkpointListeners, [checkpointId]);\n    };\n    const clearCheckpointIds = (checkpointIds, to) =>\n      arrayForEach(\n        arrayClear(checkpointIds, to ?? size(checkpointIds)),\n        clearCheckpointId,\n      );\n    const trimBackwardsIds = () =>\n      clearCheckpointIds(backwardIds, size(backwardIds) - backwardIdsSize);\n    const storeChanged = () =>\n      ifNotUndefined(currentId, () => {\n        arrayPush(backwardIds, currentId);\n        trimBackwardsIds();\n        clearCheckpointIds(forwardIds);\n        currentId = void 0;\n        checkpointsChanged = 1;\n      });\n    const storeUnchanged = () => {\n      currentId = arrayPop(backwardIds);\n      checkpointsChanged = 1;\n    };\n    let cellListenerId;\n    let valueListenerId;\n    const addCheckpointImpl = (label = EMPTY_STRING) => {\n      if (isUndefined(currentId)) {\n        currentId = EMPTY_STRING + nextCheckpointId++;\n        mapSet(deltas, currentId, [cellsDelta, valuesDelta]);\n        setCheckpoint(currentId, label);\n        cellsDelta = mapNew();\n        valuesDelta = mapNew();\n        checkpointsChanged = 1;\n      }\n      return currentId;\n    };\n    const goBackwardImpl = () => {\n      if (!arrayIsEmpty(backwardIds)) {\n        arrayUnshift(forwardIds, addCheckpointImpl());\n        updateStore(0, currentId);\n        currentId = arrayPop(backwardIds);\n        checkpointsChanged = 1;\n      }\n    };\n    const goForwardImpl = () => {\n      if (!arrayIsEmpty(forwardIds)) {\n        arrayPush(backwardIds, currentId);\n        currentId = arrayShift(forwardIds);\n        updateStore(1, currentId);\n        checkpointsChanged = 1;\n      }\n    };\n    const callListenersIfChanged = () => {\n      if (checkpointsChanged) {\n        callListeners(checkpointIdsListeners);\n        checkpointsChanged = 0;\n      }\n    };\n    const setSize = (size2) => {\n      backwardIdsSize = size2;\n      trimBackwardsIds();\n      return checkpoints;\n    };\n    const addCheckpoint = (label) => {\n      const id = addCheckpointImpl(label);\n      callListenersIfChanged();\n      return id;\n    };\n    const setCheckpoint = (checkpointId, label) => {\n      if (\n        hasCheckpoint(checkpointId) &&\n        mapGet(labels, checkpointId) !== label\n      ) {\n        mapSet(labels, checkpointId, label);\n        callListeners(checkpointListeners, [checkpointId]);\n      }\n      return checkpoints;\n    };\n    const getStore = () => store;\n    const getCheckpointIds = () => [\n      [...backwardIds],\n      currentId,\n      [...forwardIds],\n    ];\n    const forEachCheckpoint = (checkpointCallback) =>\n      mapForEach(labels, checkpointCallback);\n    const hasCheckpoint = (checkpointId) => collHas(deltas, checkpointId);\n    const getCheckpoint = (checkpointId) => mapGet(labels, checkpointId);\n    const goBackward = () => {\n      goBackwardImpl();\n      callListenersIfChanged();\n      return checkpoints;\n    };\n    const goForward = () => {\n      goForwardImpl();\n      callListenersIfChanged();\n      return checkpoints;\n    };\n    const goTo = (checkpointId) => {\n      const action = arrayHas(backwardIds, checkpointId)\n        ? goBackwardImpl\n        : arrayHas(forwardIds, checkpointId)\n          ? goForwardImpl\n          : void 0;\n      while (!isUndefined(action) && checkpointId != currentId) {\n        action();\n      }\n      callListenersIfChanged();\n      return checkpoints;\n    };\n    const addCheckpointIdsListener = (listener) =>\n      addListener(listener, checkpointIdsListeners);\n    const addCheckpointListener = (checkpointId, listener) =>\n      addListener(listener, checkpointListeners, [checkpointId]);\n    const delListener = (listenerId) => {\n      delListenerImpl(listenerId);\n      return checkpoints;\n    };\n    const clear = () => {\n      clearCheckpointIds(backwardIds);\n      clearCheckpointIds(forwardIds);\n      if (!isUndefined(currentId)) {\n        clearCheckpointId(currentId);\n      }\n      currentId = void 0;\n      nextCheckpointId = 0;\n      addCheckpoint();\n      return checkpoints;\n    };\n    const clearForward = () => {\n      if (!arrayIsEmpty(forwardIds)) {\n        clearCheckpointIds(forwardIds);\n        callListeners(checkpointIdsListeners);\n      }\n      return checkpoints;\n    };\n    const destroy = () => {\n      store.delListener(cellListenerId);\n      store.delListener(valueListenerId);\n    };\n    const getListenerStats = () => ({\n      checkpointIds: collSize2(checkpointIdsListeners),\n      checkpoint: collSize2(checkpointListeners),\n    });\n    const _registerListeners = () => {\n      cellListenerId = store.addCellListener(\n        null,\n        null,\n        null,\n        (_store, tableId, rowId, cellId, newCell, oldCell) => {\n          if (listening) {\n            storeChanged();\n            const table = mapEnsure(cellsDelta, tableId, mapNew);\n            const row = mapEnsure(table, rowId, mapNew);\n            const oldNew = mapEnsure(row, cellId, () => [oldCell, void 0]);\n            oldNew[1] = newCell;\n            if (\n              oldNew[0] === newCell &&\n              collIsEmpty(mapSet(row, cellId)) &&\n              collIsEmpty(mapSet(table, rowId)) &&\n              collIsEmpty(mapSet(cellsDelta, tableId))\n            ) {\n              storeUnchanged();\n            }\n            callListenersIfChanged();\n          }\n        },\n      );\n      valueListenerId = store.addValueListener(\n        null,\n        (_store, valueId, newValue, oldValue) => {\n          if (listening) {\n            storeChanged();\n            const oldNew = mapEnsure(valuesDelta, valueId, () => [\n              oldValue,\n              void 0,\n            ]);\n            oldNew[1] = newValue;\n            if (\n              oldNew[0] === newValue &&\n              collIsEmpty(mapSet(valuesDelta, valueId))\n            ) {\n              storeUnchanged();\n            }\n            callListenersIfChanged();\n          }\n        },\n      );\n    };\n    const checkpoints = {\n      setSize,\n      addCheckpoint,\n      setCheckpoint,\n      getStore,\n      getCheckpointIds,\n      forEachCheckpoint,\n      hasCheckpoint,\n      getCheckpoint,\n      goBackward,\n      goForward,\n      goTo,\n      addCheckpointIdsListener,\n      addCheckpointListener,\n      delListener,\n      clear,\n      clearForward,\n      destroy,\n      getListenerStats,\n      _registerListeners,\n    };\n    return objFreeze(checkpoints.clear());\n  },\n  (checkpoints) => checkpoints._registerListeners(),\n);\n\nconst MASK6 = 63;\nconst ENCODE = /* @__PURE__ */ strSplit(\n  '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz',\n);\nconst DECODE = /* @__PURE__ */ mapNew(\n  /* @__PURE__ */ arrayMap(ENCODE, (char, index) => [char, index]),\n);\nconst encode = (num) => ENCODE[num & MASK6];\nconst decode = (str, pos) => mapGet(DECODE, str[pos]) ?? 0;\nconst getRandomValues = GLOBAL.crypto\n  ? (array) => GLOBAL.crypto.getRandomValues(array)\n  : /* istanbul ignore next */\n    (array) => arrayMap(array, () => mathFloor(math.random() * 256));\nconst getUniqueId = (length = 16) =>\n  arrayReduce(\n    getRandomValues(new Uint8Array(length)),\n    (uniqueId, number) => uniqueId + encode(number),\n    EMPTY_STRING,\n  );\n\nconst jsonString = JSON.stringify;\nconst jsonParse = JSON.parse;\nconst jsonStringWithMap = (obj) =>\n  jsonString(obj, (_key, value) =>\n    isInstanceOf(value, Map) ? object.fromEntries([...value]) : value,\n  );\n\nconst textEncoder = /* @__PURE__ */ new GLOBAL.TextEncoder();\nconst getHash = (string) => {\n  let hash = 2166136261;\n  arrayForEach(textEncoder.encode(string), (char) => {\n    hash ^= char;\n    hash +=\n      (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);\n  });\n  return hash >>> 0;\n};\nconst addOrRemoveHash = (hash1, hash2) => (hash1 ^ hash2) >>> 0;\nconst getValuesHash = (valueHashes) =>\n  arrayReduce(\n    objEntries(valueHashes),\n    (valuesHash, [valueId, valueHash]) =>\n      addOrRemoveHash(\n        valuesHash,\n        getValueInValuesHash(valueId, valueHash) ^\n          getValueInValuesHash(valueId, 0),\n        // legacy v5; remove in v7\n      ),\n    0,\n    // legacy v5; valuesHlc in v7?\n  );\nconst getValueInValuesHash = (valueId, valueHash) =>\n  getHash(valueId + ':' + valueHash);\nconst getValueHash = (value, valueHlc) =>\n  getHash(jsonStringWithMap(value ?? null) + ':' + valueHlc);\nconst getCellHash = getValueHash;\nconst getCellInRowHash = getValueInValuesHash;\nconst getRowHash = getValuesHash;\nconst getRowInTableHash = getValueInValuesHash;\nconst getTableHash = (rowHashes) =>\n  // alias to getValuesHash in v7\n  arrayReduce(\n    objEntries(rowHashes),\n    (valuesHash, [rowId, rowHash]) =>\n      addOrRemoveHash(valuesHash, getValueInValuesHash(rowId, rowHash)),\n    0,\n    // legacy v5; rowHlc in v7?\n  );\nconst getTableInTablesHash = getValueInValuesHash;\nconst getTablesHash = getTableHash;\n\nconst SHIFT36 = 2 ** 36;\nconst SHIFT30 = 2 ** 30;\nconst SHIFT24 = 2 ** 24;\nconst SHIFT18 = 2 ** 18;\nconst SHIFT12 = 2 ** 12;\nconst SHIFT6 = 2 ** 6;\nconst getClientIdFromUniqueId = (uniqueId) => {\n  const clientHash30 = getHash(uniqueId);\n  return (\n    encode(clientHash30 / SHIFT24) +\n    encode(clientHash30 / SHIFT18) +\n    encode(clientHash30 / SHIFT12) +\n    encode(clientHash30 / SHIFT6) +\n    encode(clientHash30)\n  );\n};\nconst getHlcFunctions = (uniqueId, getNow = Date.now) => {\n  let lastLogicalTime = 0;\n  let lastCounter = -1;\n  const thisClientId = ifNotUndefined(uniqueId, getClientIdFromUniqueId, () =>\n    getUniqueId(5),\n  );\n  const getNextHlc = () => {\n    seenHlc();\n    return encodeHlc(lastLogicalTime, ++lastCounter);\n  };\n  const seenHlc = (hlc) => {\n    const previousLogicalTime = lastLogicalTime;\n    const [remoteLogicalTime, remoteCounter] =\n      isUndefined(hlc) || hlc == '' ? [0, 0] : decodeHlc(hlc);\n    lastLogicalTime = mathMax(previousLogicalTime, remoteLogicalTime, getNow());\n    lastCounter =\n      lastLogicalTime == previousLogicalTime\n        ? lastLogicalTime == remoteLogicalTime\n          ? mathMax(lastCounter, remoteCounter)\n          : lastCounter\n        : lastLogicalTime == remoteLogicalTime\n          ? remoteCounter\n          : -1;\n  };\n  const encodeHlc = (logicalTime42, counter24, clientId) =>\n    encode(logicalTime42 / SHIFT36) +\n    encode(logicalTime42 / SHIFT30) +\n    encode(logicalTime42 / SHIFT24) +\n    encode(logicalTime42 / SHIFT18) +\n    encode(logicalTime42 / SHIFT12) +\n    encode(logicalTime42 / SHIFT6) +\n    encode(logicalTime42) +\n    encode(counter24 / SHIFT18) +\n    encode(counter24 / SHIFT12) +\n    encode(counter24 / SHIFT6) +\n    encode(counter24) +\n    (isUndefined(clientId) ? thisClientId : getClientIdFromUniqueId(clientId));\n  const decodeHlc = (hlc16) => [\n    decode(hlc16, 0) * SHIFT36 +\n      decode(hlc16, 1) * SHIFT30 +\n      decode(hlc16, 2) * SHIFT24 +\n      decode(hlc16, 3) * SHIFT18 +\n      decode(hlc16, 4) * SHIFT12 +\n      decode(hlc16, 5) * SHIFT6 +\n      decode(hlc16, 6),\n    decode(hlc16, 7) * SHIFT18 +\n      decode(hlc16, 8) * SHIFT12 +\n      decode(hlc16, 9) * SHIFT6 +\n      decode(hlc16, 10),\n    hlc16.slice(11),\n  ];\n  const getLastLogicalTime = () => lastLogicalTime;\n  const getLastCounter = () => lastCounter;\n  const getClientId = () => thisClientId;\n  return [\n    getNextHlc,\n    seenHlc,\n    encodeHlc,\n    decodeHlc,\n    getLastLogicalTime,\n    getLastCounter,\n    getClientId,\n  ];\n};\n\nconst defaultSorter = (sortKey1, sortKey2) =>\n  (sortKey1 ?? 0) < (sortKey2 ?? 0) ? -1 : 1;\n\nconst createIndexes = getCreateFunction((store) => {\n  const sliceIdsListeners = mapNew();\n  const sliceRowIdsListeners = mapNew();\n  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(\n    () => indexes,\n  );\n  const [\n    getStore,\n    getIndexIds,\n    forEachIndexImpl,\n    hasIndex,\n    getTableId,\n    getIndex,\n    setIndex,\n    ,\n    setDefinitionAndListen,\n    delDefinition,\n    addIndexIdsListener,\n    destroy,\n  ] = getDefinableFunctions(\n    store,\n    mapNew,\n    (value) =>\n      isUndefined(value)\n        ? EMPTY_STRING\n        : isArray(value)\n          ? arrayMap(value, id)\n          : id(value),\n    addListener,\n    callListeners,\n  );\n  const hasSlice = (indexId, sliceId) => collHas(getIndex(indexId), sliceId);\n  const setIndexDefinition = (\n    indexId,\n    tableId,\n    getSliceIdOrIds,\n    getSortKey,\n    sliceIdSorter,\n    rowIdSorter = defaultSorter,\n  ) => {\n    const sliceIdArraySorter = isUndefined(sliceIdSorter)\n      ? void 0\n      : ([id1], [id2]) => sliceIdSorter(id1, id2);\n    setDefinitionAndListen(\n      indexId,\n      tableId,\n      (\n        change,\n        changedSliceIds,\n        changedSortKeys,\n        sliceIdOrIdsByRowId,\n        sortKeys,\n        force,\n      ) => {\n        let sliceIdsChanged = 0;\n        const changedSlices = setNew();\n        const unsortedSlices = setNew();\n        const index = getIndex(indexId);\n        collForEach(\n          changedSliceIds,\n          ([oldSliceIdOrIds, newSliceIdOrIds], rowId) => {\n            const oldSliceIds = setNew(oldSliceIdOrIds);\n            const newSliceIds = setNew(newSliceIdOrIds);\n            collForEach(oldSliceIds, (oldSliceId) =>\n              collDel(newSliceIds, oldSliceId)\n                ? collDel(oldSliceIds, oldSliceId)\n                : 0,\n            );\n            collForEach(oldSliceIds, (oldSliceId) => {\n              setAdd(changedSlices, oldSliceId);\n              ifNotUndefined(mapGet(index, oldSliceId), (oldSlice) => {\n                collDel(oldSlice, rowId);\n                if (collIsEmpty(oldSlice)) {\n                  mapSet(index, oldSliceId);\n                  sliceIdsChanged = 1;\n                }\n              });\n            });\n            collForEach(newSliceIds, (newSliceId) => {\n              setAdd(changedSlices, newSliceId);\n              if (!collHas(index, newSliceId)) {\n                mapSet(index, newSliceId, setNew());\n                sliceIdsChanged = 1;\n              }\n              setAdd(mapGet(index, newSliceId), rowId);\n              if (!isUndefined(getSortKey)) {\n                setAdd(unsortedSlices, newSliceId);\n              }\n            });\n          },\n        );\n        change();\n        if (!collIsEmpty(sortKeys)) {\n          if (force) {\n            mapForEach(index, (sliceId) => setAdd(unsortedSlices, sliceId));\n          } else {\n            mapForEach(changedSortKeys, (rowId) =>\n              ifNotUndefined(\n                mapGet(sliceIdOrIdsByRowId, rowId),\n                (sliceIdOrIds) =>\n                  arrayForEach(\n                    isArray(sliceIdOrIds) ? sliceIdOrIds : [sliceIdOrIds],\n                    (sliceId) => setAdd(unsortedSlices, sliceId),\n                  ),\n              ),\n            );\n          }\n          collForEach(unsortedSlices, (sliceId) => {\n            const rowIdArraySorter = (rowId1, rowId2) =>\n              rowIdSorter(\n                mapGet(sortKeys, rowId1),\n                mapGet(sortKeys, rowId2),\n                sliceId,\n              );\n            const sliceArray = [...mapGet(index, sliceId)];\n            if (!arrayIsSorted(sliceArray, rowIdArraySorter)) {\n              mapSet(\n                index,\n                sliceId,\n                setNew(arraySort(sliceArray, rowIdArraySorter)),\n              );\n              setAdd(changedSlices, sliceId);\n            }\n          });\n        }\n        if (sliceIdsChanged || force) {\n          if (!isUndefined(sliceIdArraySorter)) {\n            const indexArray = [...index];\n            if (!arrayIsSorted(indexArray, sliceIdArraySorter)) {\n              setIndex(\n                indexId,\n                mapNew(arraySort(indexArray, sliceIdArraySorter)),\n              );\n              sliceIdsChanged = 1;\n            }\n          }\n        }\n        if (sliceIdsChanged) {\n          callListeners(sliceIdsListeners, [indexId]);\n        }\n        collForEach(changedSlices, (sliceId) =>\n          callListeners(sliceRowIdsListeners, [indexId, sliceId]),\n        );\n      },\n      getRowCellFunction(getSliceIdOrIds),\n      ifNotUndefined(getSortKey, getRowCellFunction),\n    );\n    return indexes;\n  };\n  const forEachIndex = (indexCallback) =>\n    forEachIndexImpl((indexId, slices) =>\n      indexCallback(indexId, (sliceCallback) =>\n        forEachSliceImpl(indexId, sliceCallback, slices),\n      ),\n    );\n  const forEachSlice = (indexId, sliceCallback) =>\n    forEachSliceImpl(indexId, sliceCallback, getIndex(indexId));\n  const forEachSliceImpl = (indexId, sliceCallback, slices) => {\n    const tableId = getTableId(indexId);\n    collForEach(slices, (rowIds, sliceId) =>\n      sliceCallback(sliceId, (rowCallback) =>\n        collForEach(rowIds, (rowId) =>\n          rowCallback(rowId, (cellCallback) =>\n            store.forEachCell(tableId, rowId, cellCallback),\n          ),\n        ),\n      ),\n    );\n  };\n  const delIndexDefinition = (indexId) => {\n    delDefinition(indexId);\n    return indexes;\n  };\n  const getSliceIds = (indexId) => mapKeys(getIndex(indexId));\n  const getSliceRowIds = (indexId, sliceId) =>\n    collValues(mapGet(getIndex(indexId), sliceId));\n  const addSliceIdsListener = (indexId, listener) =>\n    addListener(listener, sliceIdsListeners, [indexId]);\n  const addSliceRowIdsListener = (indexId, sliceId, listener) =>\n    addListener(listener, sliceRowIdsListeners, [indexId, sliceId]);\n  const delListener = (listenerId) => {\n    delListenerImpl(listenerId);\n    return indexes;\n  };\n  const getListenerStats = () => ({\n    sliceIds: collSize2(sliceIdsListeners),\n    sliceRowIds: collSize3(sliceRowIdsListeners),\n  });\n  const indexes = {\n    setIndexDefinition,\n    delIndexDefinition,\n    getStore,\n    getIndexIds,\n    forEachIndex,\n    forEachSlice,\n    hasIndex,\n    hasSlice,\n    getTableId,\n    getSliceIds,\n    getSliceRowIds,\n    addIndexIdsListener,\n    addSliceIdsListener,\n    addSliceRowIdsListener,\n    delListener,\n    destroy,\n    getListenerStats,\n  };\n  return objFreeze(indexes);\n});\n\nconst stampClone = ([value, hlc]) => stampNew(value, hlc);\nconst stampCloneWithHash = ([value, hlc, hash]) => [value, hlc, hash];\nconst stampNew = (value, hlc) => (hlc ? [value, hlc] : [value]);\nconst stampNewWithHash = (value, hlc, hash) => [value, hlc, hash];\nconst getStampHash = (stamp) => stamp[2];\nconst replaceHlcHash = (oldHlc, newHlc) =>\n  newHlc > oldHlc ? (oldHlc ? getHash(oldHlc) : 0) ^ getHash(newHlc) : 0;\nconst getLatestHlc = (hlc1, hlc2) =>\n  /* istanbul ignore next */\n  ((hlc1 ?? '') > (hlc2 ?? '') ? hlc1 : hlc2) ?? '';\nconst stampUpdate = (stamp, hlc, hash) => {\n  if (hlc > stamp[1]) {\n    stamp[1] = hlc;\n  }\n  stamp[2] = hash >>> 0;\n};\nconst stampNewObj = (hlc = EMPTY_STRING) => stampNew(objNew(), hlc);\nconst stampNewMap = (hlc = EMPTY_STRING) => [mapNew(), hlc, 0];\nconst stampMapToObjWithHash = (\n  [map, hlc, hash],\n  mapper = stampCloneWithHash,\n) => [mapToObj(map, mapper), hlc, hash];\nconst stampMapToObjWithoutHash = ([map, hlc], mapper = stampClone) =>\n  stampNew(mapToObj(map, mapper), hlc);\nconst stampValidate = (stamp, validateThing) =>\n  isArray(stamp) &&\n  size(stamp) == 3 &&\n  isString(stamp[1]) &&\n  getTypeOf(stamp[2]) == NUMBER &&\n  isFiniteNumber(stamp[2]) &&\n  validateThing(stamp[0]);\n\nconst pairNew = (value) => [value, value];\nconst pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);\nconst pairNewMap = () => [mapNew(), mapNew()];\nconst pairClone = (array) => [...array];\nconst pairIsEqual = ([entry1, entry2]) => entry1 === entry2;\n\nconst idsChanged = (changedIds, id2, addedOrRemoved) =>\n  mapSet(\n    changedIds,\n    id2,\n    mapGet(changedIds, id2) == -addedOrRemoved ? void 0 : addedOrRemoved,\n  );\nconst createStore = () => {\n  let hasTablesSchema;\n  let hasValuesSchema;\n  let hadTables = false;\n  let hadValues = false;\n  let transactions = 0;\n  let internalListeners = [];\n  let mutating = 0;\n  const changedTableIds = mapNew();\n  const changedTableCellIds = mapNew();\n  const changedRowCount = mapNew();\n  const changedRowIds = mapNew();\n  const changedCellIds = mapNew();\n  const changedCells = mapNew();\n  const changedValueIds = mapNew();\n  const changedValues = mapNew();\n  const invalidCells = mapNew();\n  const invalidValues = mapNew();\n  const tablesSchemaMap = mapNew();\n  const tablesSchemaRowCache = mapNew();\n  const valuesSchemaMap = mapNew();\n  const valuesDefaulted = mapNew();\n  const valuesNonDefaulted = setNew();\n  const tablePoolFunctions = mapNew();\n  const tableCellIds = mapNew();\n  const tablesMap = mapNew();\n  const valuesMap = mapNew();\n  const hasTablesListeners = pairNewMap();\n  const tablesListeners = pairNewMap();\n  const tableIdsListeners = pairNewMap();\n  const hasTableListeners = pairNewMap();\n  const tableListeners = pairNewMap();\n  const tableCellIdsListeners = pairNewMap();\n  const hasTableCellListeners = pairNewMap();\n  const rowCountListeners = pairNewMap();\n  const rowIdsListeners = pairNewMap();\n  const sortedRowIdsListeners = pairNewMap();\n  const hasRowListeners = pairNewMap();\n  const rowListeners = pairNewMap();\n  const cellIdsListeners = pairNewMap();\n  const hasCellListeners = pairNewMap();\n  const cellListeners = pairNewMap();\n  const invalidCellListeners = pairNewMap();\n  const invalidValueListeners = pairNewMap();\n  const hasValuesListeners = pairNewMap();\n  const valuesListeners = pairNewMap();\n  const valueIdsListeners = pairNewMap();\n  const hasValueListeners = pairNewMap();\n  const valueListeners = pairNewMap();\n  const startTransactionListeners = mapNew();\n  const finishTransactionListeners = pairNewMap();\n  const [addListener, callListeners, delListenerImpl, callListenerImpl] =\n    getListenerFunctions(() => store);\n  const validateTablesSchema = (tableSchema) =>\n    objValidate(tableSchema, (tableSchema2) =>\n      objValidate(tableSchema2, validateCellOrValueSchema),\n    );\n  const validateValuesSchema = (valuesSchema) =>\n    objValidate(valuesSchema, validateCellOrValueSchema);\n  const validateCellOrValueSchema = (schema) => {\n    if (\n      !objValidate(schema, (_child, id2) =>\n        arrayHas([TYPE, DEFAULT, ALLOW_NULL], id2),\n      )\n    ) {\n      return false;\n    }\n    const type = schema[TYPE];\n    if (!isTypeStringOrBoolean(type) && type != NUMBER) {\n      return false;\n    }\n    const defaultValue = schema[DEFAULT];\n    if (isNull(defaultValue) && !schema[ALLOW_NULL]) {\n      return false;\n    }\n    if (!isNull(defaultValue) && getCellOrValueType(defaultValue) != type) {\n      objDel(schema, DEFAULT);\n    }\n    return true;\n  };\n  const validateContent = isArray;\n  const validateTables = (tables) =>\n    objValidate(tables, validateTable, cellInvalid);\n  const validateTable = (table, tableId) =>\n    (!hasTablesSchema ||\n      collHas(tablesSchemaMap, tableId) ||\n      /* istanbul ignore next */\n      cellInvalid(tableId)) &&\n    objValidate(\n      table,\n      (row, rowId) => validateRow(tableId, rowId, row),\n      () => cellInvalid(tableId),\n    );\n  const validateRow = (tableId, rowId, row, skipDefaults) =>\n    objValidate(\n      skipDefaults ? row : addDefaultsToRow(row, tableId, rowId),\n      (cell, cellId) =>\n        ifNotUndefined(\n          getValidatedCell(tableId, rowId, cellId, cell),\n          (validCell) => {\n            row[cellId] = validCell;\n            return true;\n          },\n          () => false,\n        ),\n      () => cellInvalid(tableId, rowId),\n    );\n  const getValidatedCell = (tableId, rowId, cellId, cell) =>\n    hasTablesSchema\n      ? ifNotUndefined(\n          mapGet(mapGet(tablesSchemaMap, tableId), cellId),\n          (cellSchema) =>\n            isNull(cell)\n              ? cellSchema[ALLOW_NULL]\n                ? cell\n                : cellInvalid(tableId, rowId, cellId, cell, cellSchema[DEFAULT])\n              : getCellOrValueType(cell) == cellSchema[TYPE]\n                ? cell\n                : cellInvalid(\n                    tableId,\n                    rowId,\n                    cellId,\n                    cell,\n                    cellSchema[DEFAULT],\n                  ),\n          () => cellInvalid(tableId, rowId, cellId, cell),\n        )\n      : isUndefined(getCellOrValueType(cell))\n        ? cellInvalid(tableId, rowId, cellId, cell)\n        : cell;\n  const validateValues = (values, skipDefaults) =>\n    objValidate(\n      skipDefaults ? values : addDefaultsToValues(values),\n      (value, valueId) =>\n        ifNotUndefined(\n          getValidatedValue(valueId, value),\n          (validValue) => {\n            values[valueId] = validValue;\n            return true;\n          },\n          () => false,\n        ),\n      () => valueInvalid(),\n    );\n  const getValidatedValue = (valueId, value) =>\n    hasValuesSchema\n      ? ifNotUndefined(\n          mapGet(valuesSchemaMap, valueId),\n          (valueSchema) =>\n            isNull(value)\n              ? valueSchema[ALLOW_NULL]\n                ? value\n                : valueInvalid(valueId, value, valueSchema[DEFAULT])\n              : getCellOrValueType(value) == valueSchema[TYPE]\n                ? value\n                : valueInvalid(valueId, value, valueSchema[DEFAULT]),\n          () => valueInvalid(valueId, value),\n        )\n      : isUndefined(getCellOrValueType(value))\n        ? valueInvalid(valueId, value)\n        : value;\n  const addDefaultsToRow = (row, tableId, rowId) => {\n    ifNotUndefined(\n      mapGet(tablesSchemaRowCache, tableId),\n      ([rowDefaulted, rowNonDefaulted]) => {\n        collForEach(rowDefaulted, (cell, cellId) => {\n          if (!objHas(row, cellId)) {\n            row[cellId] = cell;\n          }\n        });\n        collForEach(rowNonDefaulted, (cellId) => {\n          if (!objHas(row, cellId)) {\n            cellInvalid(tableId, rowId, cellId);\n          }\n        });\n      },\n    );\n    return row;\n  };\n  const addDefaultsToValues = (values) => {\n    if (hasValuesSchema) {\n      collForEach(valuesDefaulted, (value, valueId) => {\n        if (!objHas(values, valueId)) {\n          values[valueId] = value;\n        }\n      });\n      collForEach(valuesNonDefaulted, (valueId) => {\n        if (!objHas(values, valueId)) {\n          valueInvalid(valueId);\n        }\n      });\n    }\n    return values;\n  };\n  const setValidTablesSchema = (tablesSchema) =>\n    mapMatch(\n      tablesSchemaMap,\n      tablesSchema,\n      (_tablesSchema, tableId, tableSchema) => {\n        const rowDefaulted = mapNew();\n        const rowNonDefaulted = setNew();\n        mapMatch(\n          mapEnsure(tablesSchemaMap, tableId, mapNew),\n          tableSchema,\n          (tableSchemaMap, cellId, cellSchema) => {\n            mapSet(tableSchemaMap, cellId, cellSchema);\n            ifNotUndefined(\n              cellSchema[DEFAULT],\n              (def) => mapSet(rowDefaulted, cellId, def),\n              () => setAdd(rowNonDefaulted, cellId),\n            );\n          },\n        );\n        mapSet(tablesSchemaRowCache, tableId, [rowDefaulted, rowNonDefaulted]);\n      },\n      (_tablesSchema, tableId) => {\n        mapSet(tablesSchemaMap, tableId);\n        mapSet(tablesSchemaRowCache, tableId);\n      },\n    );\n  const setValidValuesSchema = (valuesSchema) =>\n    mapMatch(\n      valuesSchemaMap,\n      valuesSchema,\n      (_valuesSchema, valueId, valueSchema) => {\n        mapSet(valuesSchemaMap, valueId, valueSchema);\n        ifNotUndefined(\n          valueSchema[DEFAULT],\n          (def) => mapSet(valuesDefaulted, valueId, def),\n          () => setAdd(valuesNonDefaulted, valueId),\n        );\n      },\n      (_valuesSchema, valueId) => {\n        mapSet(valuesSchemaMap, valueId);\n        mapSet(valuesDefaulted, valueId);\n        collDel(valuesNonDefaulted, valueId);\n      },\n    );\n  const setOrDelTables = (tables) =>\n    objIsEmpty(tables) ? delTables() : setTables(tables);\n  const setValidContent = ([tables, values]) => {\n    (objIsEmpty(tables) ? delTables : setTables)(tables);\n    (objIsEmpty(values) ? delValues : setValues)(values);\n  };\n  const setValidTables = (tables) =>\n    mapMatch(\n      tablesMap,\n      tables,\n      (_tables, tableId, table) => setValidTable(tableId, table),\n      (_tables, tableId) => delValidTable(tableId),\n    );\n  const setValidTable = (tableId, table) =>\n    mapMatch(\n      mapEnsure(tablesMap, tableId, () => {\n        tableIdsChanged(tableId, 1);\n        mapSet(tablePoolFunctions, tableId, getPoolFunctions());\n        mapSet(tableCellIds, tableId, mapNew());\n        return mapNew();\n      }),\n      table,\n      (tableMap, rowId, row) => setValidRow(tableId, tableMap, rowId, row),\n      (tableMap, rowId) => delValidRow(tableId, tableMap, rowId),\n    );\n  const setValidRow = (tableId, tableMap, rowId, row, forceDel) =>\n    mapMatch(\n      mapEnsure(tableMap, rowId, () => {\n        rowIdsChanged(tableId, rowId, 1);\n        return mapNew();\n      }),\n      row,\n      (rowMap, cellId, cell) =>\n        setValidCell(tableId, rowId, rowMap, cellId, cell),\n      (rowMap, cellId) =>\n        delValidCell(tableId, tableMap, rowId, rowMap, cellId, forceDel),\n    );\n  const setValidCell = (tableId, rowId, rowMap, cellId, cell) => {\n    if (!collHas(rowMap, cellId)) {\n      cellIdsChanged(tableId, rowId, cellId, 1);\n    }\n    const oldCell = mapGet(rowMap, cellId);\n    if (cell !== oldCell) {\n      cellChanged(tableId, rowId, cellId, oldCell, cell);\n      mapSet(rowMap, cellId, cell);\n    }\n  };\n  const setCellIntoDefaultRow = (tableId, tableMap, rowId, cellId, validCell) =>\n    ifNotUndefined(\n      mapGet(tableMap, rowId),\n      (rowMap) => setValidCell(tableId, rowId, rowMap, cellId, validCell),\n      () =>\n        setValidRow(\n          tableId,\n          tableMap,\n          rowId,\n          addDefaultsToRow({[cellId]: validCell}, tableId, rowId),\n        ),\n    );\n  const setOrDelValues = (values) =>\n    objIsEmpty(values) ? delValues() : setValues(values);\n  const setValidValues = (values) =>\n    mapMatch(\n      valuesMap,\n      values,\n      (_valuesMap, valueId, value) => setValidValue(valueId, value),\n      (_valuesMap, valueId) => delValidValue(valueId),\n    );\n  const setValidValue = (valueId, value) => {\n    if (!collHas(valuesMap, valueId)) {\n      valueIdsChanged(valueId, 1);\n    }\n    const oldValue = mapGet(valuesMap, valueId);\n    if (value !== oldValue) {\n      valueChanged(valueId, oldValue, value);\n      mapSet(valuesMap, valueId, value);\n    }\n  };\n  const getNewRowId = (tableId, reuse) => {\n    const [getId] = mapGet(tablePoolFunctions, tableId);\n    let rowId;\n    do {\n      rowId = getId(reuse);\n    } while (collHas(mapGet(tablesMap, tableId), rowId));\n    return rowId;\n  };\n  const getOrCreateTable = (tableId) =>\n    mapGet(tablesMap, tableId) ?? setValidTable(tableId, {});\n  const delValidTable = (tableId) => setValidTable(tableId, {});\n  const delValidRow = (tableId, tableMap, rowId) => {\n    const [, releaseId] = mapGet(tablePoolFunctions, tableId);\n    releaseId(rowId);\n    setValidRow(tableId, tableMap, rowId, {}, true);\n  };\n  const delValidCell = (tableId, table, rowId, row, cellId, forceDel) => {\n    const defaultCell = mapGet(\n      mapGet(tablesSchemaRowCache, tableId)?.[0],\n      cellId,\n    );\n    if (!isUndefined(defaultCell) && !forceDel) {\n      return setValidCell(tableId, rowId, row, cellId, defaultCell);\n    }\n    const delCell2 = (cellId2) => {\n      cellChanged(tableId, rowId, cellId2, mapGet(row, cellId2));\n      cellIdsChanged(tableId, rowId, cellId2, -1);\n      mapSet(row, cellId2);\n    };\n    if (isUndefined(defaultCell)) {\n      delCell2(cellId);\n    } else {\n      mapForEach(row, delCell2);\n    }\n    if (collIsEmpty(row)) {\n      rowIdsChanged(tableId, rowId, -1);\n      if (collIsEmpty(mapSet(table, rowId))) {\n        tableIdsChanged(tableId, -1);\n        mapSet(tablesMap, tableId);\n        mapSet(tablePoolFunctions, tableId);\n        mapSet(tableCellIds, tableId);\n      }\n    }\n  };\n  const delValidValue = (valueId) => {\n    const defaultValue = mapGet(valuesDefaulted, valueId);\n    if (!isUndefined(defaultValue)) {\n      return setValidValue(valueId, defaultValue);\n    }\n    valueChanged(valueId, mapGet(valuesMap, valueId));\n    valueIdsChanged(valueId, -1);\n    mapSet(valuesMap, valueId);\n  };\n  const tableIdsChanged = (tableId, addedOrRemoved) =>\n    idsChanged(changedTableIds, tableId, addedOrRemoved);\n  const rowIdsChanged = (tableId, rowId, addedOrRemoved) =>\n    idsChanged(\n      mapEnsure(changedRowIds, tableId, mapNew),\n      rowId,\n      addedOrRemoved,\n    ) &&\n    mapSet(\n      changedRowCount,\n      tableId,\n      mapEnsure(changedRowCount, tableId, () => 0) + addedOrRemoved,\n    );\n  const cellIdsChanged = (tableId, rowId, cellId, addedOrRemoved) => {\n    const cellIds = mapGet(tableCellIds, tableId);\n    const count = mapGet(cellIds, cellId) ?? 0;\n    if (\n      (count == 0 && addedOrRemoved == 1) ||\n      (count == 1 && addedOrRemoved == -1)\n    ) {\n      idsChanged(\n        mapEnsure(changedTableCellIds, tableId, mapNew),\n        cellId,\n        addedOrRemoved,\n      );\n    }\n    mapSet(\n      cellIds,\n      cellId,\n      count != -addedOrRemoved ? count + addedOrRemoved : void 0,\n    );\n    idsChanged(\n      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),\n      cellId,\n      addedOrRemoved,\n    );\n  };\n  const cellChanged = (tableId, rowId, cellId, oldCell, newCell) => {\n    mapEnsure(\n      mapEnsure(mapEnsure(changedCells, tableId, mapNew), rowId, mapNew),\n      cellId,\n      () => [oldCell, 0],\n    )[1] = newCell;\n    internalListeners[3]?.(tableId, rowId, cellId, newCell, mutating);\n  };\n  const valueIdsChanged = (valueId, addedOrRemoved) =>\n    idsChanged(changedValueIds, valueId, addedOrRemoved);\n  const valueChanged = (valueId, oldValue, newValue) => {\n    mapEnsure(changedValues, valueId, () => [oldValue, 0])[1] = newValue;\n    internalListeners[4]?.(valueId, newValue, mutating);\n  };\n  const cellInvalid = (tableId, rowId, cellId, invalidCell, defaultedCell) => {\n    arrayPush(\n      mapEnsure(\n        mapEnsure(mapEnsure(invalidCells, tableId, mapNew), rowId, mapNew),\n        cellId,\n        () => [],\n      ),\n      invalidCell,\n    );\n    return defaultedCell;\n  };\n  const valueInvalid = (valueId, invalidValue, defaultedValue) => {\n    arrayPush(\n      mapEnsure(invalidValues, valueId, () => []),\n      invalidValue,\n    );\n    return defaultedValue;\n  };\n  const getCellChange = (tableId, rowId, cellId) =>\n    ifNotUndefined(\n      mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),\n      ([oldCell, newCell]) => [true, oldCell, newCell],\n      () => [false, ...pairNew(getCell(tableId, rowId, cellId))],\n    );\n  const getValueChange = (valueId) =>\n    ifNotUndefined(\n      mapGet(changedValues, valueId),\n      ([oldValue, newValue]) => [true, oldValue, newValue],\n      () => [false, ...pairNew(getValue(valueId))],\n    );\n  const callInvalidCellListeners = (mutator) =>\n    !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])\n      ? collForEach(\n          mutator ? mapClone3(invalidCells) : invalidCells,\n          (rows, tableId) =>\n            collForEach(rows, (cells, rowId) =>\n              collForEach(cells, (invalidCell, cellId) =>\n                callListeners(\n                  invalidCellListeners[mutator],\n                  [tableId, rowId, cellId],\n                  invalidCell,\n                ),\n              ),\n            ),\n        )\n      : 0;\n  const callInvalidValueListeners = (mutator) =>\n    !collIsEmpty(invalidValues) && !collIsEmpty(invalidValueListeners[mutator])\n      ? collForEach(\n          mutator ? mapClone(invalidValues) : invalidValues,\n          (invalidValue, valueId) =>\n            callListeners(\n              invalidValueListeners[mutator],\n              [valueId],\n              invalidValue,\n            ),\n        )\n      : 0;\n  const callIdsAndHasListenersIfChanged = (\n    changedIds,\n    idListeners,\n    hasListeners,\n    ids,\n  ) => {\n    if (!collIsEmpty(changedIds)) {\n      callListeners(idListeners, ids, () => mapToObj(changedIds));\n      mapForEach(changedIds, (changedId, changed) =>\n        callListeners(hasListeners, [...(ids ?? []), changedId], changed == 1),\n      );\n      return 1;\n    }\n  };\n  const callTabularListenersForChanges = (mutator) => {\n    const hasHasTablesListeners = !collIsEmpty(hasTablesListeners[mutator]);\n    const hasSortedRowIdListeners = !collIsEmpty(\n      sortedRowIdsListeners[mutator],\n    );\n    const hasIdOrHasListeners = !(\n      collIsEmpty(cellIdsListeners[mutator]) &&\n      collIsEmpty(hasCellListeners[mutator]) &&\n      collIsEmpty(rowIdsListeners[mutator]) &&\n      collIsEmpty(hasRowListeners[mutator]) &&\n      collIsEmpty(tableCellIdsListeners[mutator]) &&\n      collIsEmpty(hasTableCellListeners[mutator]) &&\n      collIsEmpty(rowCountListeners[mutator]) &&\n      !hasSortedRowIdListeners &&\n      collIsEmpty(tableIdsListeners[mutator]) &&\n      collIsEmpty(hasTableListeners[mutator])\n    );\n    const hasOtherListeners = !(\n      collIsEmpty(cellListeners[mutator]) &&\n      collIsEmpty(rowListeners[mutator]) &&\n      collIsEmpty(tableListeners[mutator]) &&\n      collIsEmpty(tablesListeners[mutator])\n    );\n    if (hasHasTablesListeners || hasIdOrHasListeners || hasOtherListeners) {\n      const changes = mutator\n        ? [\n            mapClone(changedTableIds),\n            mapClone2(changedTableCellIds),\n            mapClone(changedRowCount),\n            mapClone2(changedRowIds),\n            mapClone3(changedCellIds),\n            mapClone(changedCells, (map) =>\n              mapClone(map, (map2) => mapClone(map2, pairClone)),\n            ),\n          ]\n        : [\n            changedTableIds,\n            changedTableCellIds,\n            changedRowCount,\n            changedRowIds,\n            changedCellIds,\n            changedCells,\n          ];\n      if (hasHasTablesListeners) {\n        const hasTablesNow = hasTables();\n        if (hasTablesNow != hadTables) {\n          callListeners(hasTablesListeners[mutator], void 0, hasTablesNow);\n        }\n      }\n      if (hasIdOrHasListeners) {\n        callIdsAndHasListenersIfChanged(\n          changes[0],\n          tableIdsListeners[mutator],\n          hasTableListeners[mutator],\n        );\n        collForEach(changes[1], (changedIds, tableId) =>\n          callIdsAndHasListenersIfChanged(\n            changedIds,\n            tableCellIdsListeners[mutator],\n            hasTableCellListeners[mutator],\n            [tableId],\n          ),\n        );\n        collForEach(changes[2], (changedCount, tableId) => {\n          if (changedCount != 0) {\n            callListeners(\n              rowCountListeners[mutator],\n              [tableId],\n              getRowCount(tableId),\n            );\n          }\n        });\n        const calledSortableTableIds = setNew();\n        collForEach(changes[3], (changedIds, tableId) => {\n          if (\n            callIdsAndHasListenersIfChanged(\n              changedIds,\n              rowIdsListeners[mutator],\n              hasRowListeners[mutator],\n              [tableId],\n            ) &&\n            hasSortedRowIdListeners\n          ) {\n            callListeners(sortedRowIdsListeners[mutator], [tableId, null]);\n            setAdd(calledSortableTableIds, tableId);\n          }\n        });\n        if (hasSortedRowIdListeners) {\n          collForEach(changes[5], (rows, tableId) => {\n            if (!collHas(calledSortableTableIds, tableId)) {\n              const sortableCellIds = setNew();\n              collForEach(rows, (cells) =>\n                collForEach(cells, ([oldCell, newCell], cellId) =>\n                  newCell !== oldCell\n                    ? setAdd(sortableCellIds, cellId)\n                    : collDel(cells, cellId),\n                ),\n              );\n              collForEach(sortableCellIds, (cellId) =>\n                callListeners(sortedRowIdsListeners[mutator], [\n                  tableId,\n                  cellId,\n                ]),\n              );\n            }\n          });\n        }\n        collForEach(changes[4], (rowCellIds, tableId) =>\n          collForEach(rowCellIds, (changedIds, rowId) =>\n            callIdsAndHasListenersIfChanged(\n              changedIds,\n              cellIdsListeners[mutator],\n              hasCellListeners[mutator],\n              [tableId, rowId],\n            ),\n          ),\n        );\n      }\n      if (hasOtherListeners) {\n        let tablesChanged;\n        collForEach(changes[5], (rows, tableId) => {\n          let tableChanged;\n          collForEach(rows, (cells, rowId) => {\n            let rowChanged;\n            collForEach(cells, ([oldCell, newCell], cellId) => {\n              if (newCell !== oldCell) {\n                callListeners(\n                  cellListeners[mutator],\n                  [tableId, rowId, cellId],\n                  newCell,\n                  oldCell,\n                  getCellChange,\n                );\n                tablesChanged = tableChanged = rowChanged = 1;\n              }\n            });\n            if (rowChanged) {\n              callListeners(\n                rowListeners[mutator],\n                [tableId, rowId],\n                getCellChange,\n              );\n            }\n          });\n          if (tableChanged) {\n            callListeners(tableListeners[mutator], [tableId], getCellChange);\n          }\n        });\n        if (tablesChanged) {\n          callListeners(tablesListeners[mutator], void 0, getCellChange);\n        }\n      }\n    }\n  };\n  const callValuesListenersForChanges = (mutator) => {\n    const hasHasValuesListeners = !collIsEmpty(hasValuesListeners[mutator]);\n    const hasIdOrHasListeners =\n      !collIsEmpty(valueIdsListeners[mutator]) ||\n      !collIsEmpty(hasValueListeners[mutator]);\n    const hasOtherListeners =\n      !collIsEmpty(valueListeners[mutator]) ||\n      !collIsEmpty(valuesListeners[mutator]);\n    if (hasHasValuesListeners || hasIdOrHasListeners || hasOtherListeners) {\n      const changes = mutator\n        ? [mapClone(changedValueIds), mapClone(changedValues, pairClone)]\n        : [changedValueIds, changedValues];\n      if (hasHasValuesListeners) {\n        const hasValuesNow = hasValues();\n        if (hasValuesNow != hadValues) {\n          callListeners(hasValuesListeners[mutator], void 0, hasValuesNow);\n        }\n      }\n      if (hasIdOrHasListeners) {\n        callIdsAndHasListenersIfChanged(\n          changes[0],\n          valueIdsListeners[mutator],\n          hasValueListeners[mutator],\n        );\n      }\n      if (hasOtherListeners) {\n        let valuesChanged;\n        collForEach(changes[1], ([oldValue, newValue], valueId) => {\n          if (newValue !== oldValue) {\n            callListeners(\n              valueListeners[mutator],\n              [valueId],\n              newValue,\n              oldValue,\n              getValueChange,\n            );\n            valuesChanged = 1;\n          }\n        });\n        if (valuesChanged) {\n          callListeners(valuesListeners[mutator], void 0, getValueChange);\n        }\n      }\n    }\n  };\n  const fluentTransaction = (actions, ...args) => {\n    transaction(() => actions(...arrayMap(args, id)));\n    return store;\n  };\n  const addSortedRowIdsListenerImpl = (\n    tableId,\n    cellId,\n    otherArgs,\n    listener,\n    mutator,\n  ) => {\n    let sortedRowIds = getSortedRowIds(tableId, cellId, ...otherArgs);\n    return addListener(\n      () => {\n        const newSortedRowIds = getSortedRowIds(tableId, cellId, ...otherArgs);\n        if (!arrayIsEqual(newSortedRowIds, sortedRowIds)) {\n          sortedRowIds = newSortedRowIds;\n          listener(store, tableId, cellId, ...otherArgs, sortedRowIds);\n        }\n      },\n      sortedRowIdsListeners[mutator ? 1 : 0],\n      [tableId, cellId],\n      [getTableIds],\n    );\n  };\n  const getContent = () => [getTables(), getValues()];\n  const getTables = () => mapToObj3(tablesMap);\n  const getTableIds = () => mapKeys(tablesMap);\n  const getTable = (tableId) => mapToObj2(mapGet(tablesMap, id(tableId)));\n  const getTableCellIds = (tableId) =>\n    mapKeys(mapGet(tableCellIds, id(tableId)));\n  const getRowCount = (tableId) => collSize(mapGet(tablesMap, id(tableId)));\n  const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));\n  const getSortedRowIds = (\n    tableIdOrArgs,\n    cellId,\n    descending,\n    offset = 0,\n    limit,\n  ) =>\n    isObject(tableIdOrArgs)\n      ? getSortedRowIds(\n          tableIdOrArgs.tableId,\n          tableIdOrArgs.cellId,\n          tableIdOrArgs.descending,\n          tableIdOrArgs.offset,\n          tableIdOrArgs.limit,\n        )\n      : arrayMap(\n          slice(\n            arraySort(\n              mapMap(mapGet(tablesMap, id(tableIdOrArgs)), (row, rowId) => [\n                isUndefined(cellId) ? rowId : mapGet(row, id(cellId)),\n                rowId,\n              ]),\n              ([cell1], [cell2]) =>\n                defaultSorter(cell1, cell2) * (descending ? -1 : 1),\n            ),\n            offset,\n            isUndefined(limit) ? limit : offset + limit,\n          ),\n          ([, rowId]) => rowId,\n        );\n  const getRow = (tableId, rowId) =>\n    mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));\n  const getCellIds = (tableId, rowId) =>\n    mapKeys(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));\n  const getCell = (tableId, rowId, cellId) =>\n    mapGet(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));\n  const getValues = () => mapToObj(valuesMap);\n  const getValueIds = () => mapKeys(valuesMap);\n  const getValue = (valueId) => mapGet(valuesMap, id(valueId));\n  const hasTables = () => !collIsEmpty(tablesMap);\n  const hasTable = (tableId) => collHas(tablesMap, id(tableId));\n  const hasTableCell = (tableId, cellId) =>\n    collHas(mapGet(tableCellIds, id(tableId)), id(cellId));\n  const hasRow = (tableId, rowId) =>\n    collHas(mapGet(tablesMap, id(tableId)), id(rowId));\n  const hasCell = (tableId, rowId, cellId) =>\n    collHas(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), id(cellId));\n  const hasValues = () => !collIsEmpty(valuesMap);\n  const hasValue = (valueId) => collHas(valuesMap, id(valueId));\n  const getTablesJson = () => jsonStringWithMap(tablesMap);\n  const getValuesJson = () => jsonStringWithMap(valuesMap);\n  const getJson = () => jsonStringWithMap([tablesMap, valuesMap]);\n  const getTablesSchemaJson = () => jsonStringWithMap(tablesSchemaMap);\n  const getValuesSchemaJson = () => jsonStringWithMap(valuesSchemaMap);\n  const getSchemaJson = () =>\n    jsonStringWithMap([tablesSchemaMap, valuesSchemaMap]);\n  const setContent = (content) =>\n    fluentTransaction(() => {\n      const content2 = isFunction(content) ? content() : content;\n      if (validateContent(content2)) {\n        setValidContent(content2);\n      }\n    });\n  const setTables = (tables) =>\n    fluentTransaction(() =>\n      validateTables(tables) ? setValidTables(tables) : 0,\n    );\n  const setTable = (tableId, table) =>\n    fluentTransaction(\n      (tableId2) =>\n        validateTable(table, tableId2) ? setValidTable(tableId2, table) : 0,\n      tableId,\n    );\n  const setRow = (tableId, rowId, row) =>\n    fluentTransaction(\n      (tableId2, rowId2) =>\n        validateRow(tableId2, rowId2, row)\n          ? setValidRow(tableId2, getOrCreateTable(tableId2), rowId2, row)\n          : 0,\n      tableId,\n      rowId,\n    );\n  const addRow = (tableId, row, reuseRowIds = true) =>\n    transaction(() => {\n      let rowId = void 0;\n      if (validateRow(tableId, rowId, row)) {\n        tableId = id(tableId);\n        setValidRow(\n          tableId,\n          getOrCreateTable(tableId),\n          (rowId = getNewRowId(tableId, reuseRowIds ? 1 : 0)),\n          row,\n        );\n      }\n      return rowId;\n    });\n  const setPartialRow = (tableId, rowId, partialRow) =>\n    fluentTransaction(\n      (tableId2, rowId2) => {\n        if (validateRow(tableId2, rowId2, partialRow, 1)) {\n          const table = getOrCreateTable(tableId2);\n          objMap(partialRow, (cell, cellId) =>\n            setCellIntoDefaultRow(tableId2, table, rowId2, cellId, cell),\n          );\n        }\n      },\n      tableId,\n      rowId,\n    );\n  const setCell = (tableId, rowId, cellId, cell) =>\n    fluentTransaction(\n      (tableId2, rowId2, cellId2) =>\n        ifNotUndefined(\n          getValidatedCell(\n            tableId2,\n            rowId2,\n            cellId2,\n            isFunction(cell) ? cell(getCell(tableId2, rowId2, cellId2)) : cell,\n          ),\n          (validCell) =>\n            setCellIntoDefaultRow(\n              tableId2,\n              getOrCreateTable(tableId2),\n              rowId2,\n              cellId2,\n              validCell,\n            ),\n        ),\n      tableId,\n      rowId,\n      cellId,\n    );\n  const setValues = (values) =>\n    fluentTransaction(() =>\n      validateValues(values) ? setValidValues(values) : 0,\n    );\n  const setPartialValues = (partialValues) =>\n    fluentTransaction(() =>\n      validateValues(partialValues, 1)\n        ? objMap(partialValues, (value, valueId) =>\n            setValidValue(valueId, value),\n          )\n        : 0,\n    );\n  const setValue = (valueId, value) =>\n    fluentTransaction(\n      (valueId2) =>\n        ifNotUndefined(\n          getValidatedValue(\n            valueId2,\n            isFunction(value) ? value(getValue(valueId2)) : value,\n          ),\n          (validValue) => setValidValue(valueId2, validValue),\n        ),\n      valueId,\n    );\n  const applyChanges = (changes) =>\n    fluentTransaction(() => {\n      objMap(changes[0], (table, tableId) =>\n        isUndefined(table)\n          ? delTable(tableId)\n          : objMap(table, (row, rowId) =>\n              isUndefined(row)\n                ? delRow(tableId, rowId)\n                : objMap(row, (cell, cellId) =>\n                    setOrDelCell(store, tableId, rowId, cellId, cell),\n                  ),\n            ),\n      );\n      objMap(changes[1], (value, valueId) =>\n        setOrDelValue(store, valueId, value),\n      );\n    });\n  const setTablesJson = (tablesJson) => {\n    tryCatch(() => setOrDelTables(jsonParse(tablesJson)));\n    return store;\n  };\n  const setValuesJson = (valuesJson) => {\n    tryCatch(() => setOrDelValues(jsonParse(valuesJson)));\n    return store;\n  };\n  const setJson = (tablesAndValuesJson) =>\n    fluentTransaction(() =>\n      tryCatch(\n        () => {\n          const [tables, values] = jsonParse(tablesAndValuesJson);\n          setOrDelTables(tables);\n          setOrDelValues(values);\n        },\n        () => setTablesJson(tablesAndValuesJson),\n      ),\n    );\n  const setTablesSchema = (tablesSchema) =>\n    fluentTransaction(() => {\n      if ((hasTablesSchema = validateTablesSchema(tablesSchema))) {\n        setValidTablesSchema(tablesSchema);\n        if (!collIsEmpty(tablesMap)) {\n          const tables = getTables();\n          delTables();\n          setTables(tables);\n        }\n      }\n    });\n  const setValuesSchema = (valuesSchema) =>\n    fluentTransaction(() => {\n      if ((hasValuesSchema = validateValuesSchema(valuesSchema))) {\n        const values = getValues();\n        delValuesSchema();\n        delValues();\n        hasValuesSchema = true;\n        setValidValuesSchema(valuesSchema);\n        setValues(values);\n      }\n    });\n  const setSchema = (tablesSchema, valuesSchema) =>\n    fluentTransaction(() => {\n      setTablesSchema(tablesSchema);\n      setValuesSchema(valuesSchema);\n    });\n  const delTables = () => fluentTransaction(() => setValidTables({}));\n  const delTable = (tableId) =>\n    fluentTransaction(\n      (tableId2) =>\n        collHas(tablesMap, tableId2) ? delValidTable(tableId2) : 0,\n      tableId,\n    );\n  const delRow = (tableId, rowId) =>\n    fluentTransaction(\n      (tableId2, rowId2) =>\n        ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>\n          collHas(tableMap, rowId2)\n            ? delValidRow(tableId2, tableMap, rowId2)\n            : 0,\n        ),\n      tableId,\n      rowId,\n    );\n  const delCell = (tableId, rowId, cellId, forceDel) =>\n    fluentTransaction(\n      (tableId2, rowId2, cellId2) =>\n        ifNotUndefined(mapGet(tablesMap, tableId2), (tableMap) =>\n          ifNotUndefined(mapGet(tableMap, rowId2), (rowMap) =>\n            collHas(rowMap, cellId2)\n              ? delValidCell(\n                  tableId2,\n                  tableMap,\n                  rowId2,\n                  rowMap,\n                  cellId2,\n                  forceDel,\n                )\n              : 0,\n          ),\n        ),\n      tableId,\n      rowId,\n      cellId,\n    );\n  const delValues = () => fluentTransaction(() => setValidValues({}));\n  const delValue = (valueId) =>\n    fluentTransaction(\n      (valueId2) =>\n        collHas(valuesMap, valueId2) ? delValidValue(valueId2) : 0,\n      valueId,\n    );\n  const delTablesSchema = () =>\n    fluentTransaction(() => {\n      setValidTablesSchema({});\n      hasTablesSchema = false;\n    });\n  const delValuesSchema = () =>\n    fluentTransaction(() => {\n      setValidValuesSchema({});\n      hasValuesSchema = false;\n    });\n  const delSchema = () =>\n    fluentTransaction(() => {\n      delTablesSchema();\n      delValuesSchema();\n    });\n  const transaction = (actions, doRollback) => {\n    if (transactions != -1) {\n      startTransaction();\n      const result = actions();\n      finishTransaction(doRollback);\n      return result;\n    }\n  };\n  const startTransaction = () => {\n    if (transactions != -1) {\n      transactions++;\n    }\n    if (transactions == 1) {\n      internalListeners[0]?.();\n      callListeners(startTransactionListeners);\n    }\n    return store;\n  };\n  const getTransactionChanges = () => [\n    mapToObj(\n      changedCells,\n      (table, tableId) =>\n        mapGet(changedTableIds, tableId) === -1\n          ? void 0\n          : mapToObj(\n              table,\n              (row, rowId) =>\n                mapGet(mapGet(changedRowIds, tableId), rowId) === -1\n                  ? void 0\n                  : mapToObj(\n                      row,\n                      ([, newCell]) => newCell,\n                      (changedCell) => pairIsEqual(changedCell),\n                    ),\n              collIsEmpty,\n              objIsEmpty,\n            ),\n      collIsEmpty,\n      objIsEmpty,\n    ),\n    mapToObj(\n      changedValues,\n      ([, newValue]) => newValue,\n      (changedValue) => pairIsEqual(changedValue),\n    ),\n    1,\n  ];\n  const getTransactionLog = () => [\n    !collIsEmpty(changedCells),\n    !collIsEmpty(changedValues),\n    mapToObj3(changedCells, pairClone, pairIsEqual),\n    mapToObj3(invalidCells),\n    mapToObj(changedValues, pairClone, pairIsEqual),\n    mapToObj(invalidValues),\n    mapToObj(changedTableIds),\n    mapToObj2(changedRowIds),\n    mapToObj3(changedCellIds),\n    mapToObj(changedValueIds),\n  ];\n  const finishTransaction = (doRollback) => {\n    if (transactions > 0) {\n      transactions--;\n      if (transactions == 0) {\n        transactions = 1;\n        mutating = 1;\n        callInvalidCellListeners(1);\n        if (!collIsEmpty(changedCells)) {\n          callTabularListenersForChanges(1);\n        }\n        callInvalidValueListeners(1);\n        if (!collIsEmpty(changedValues)) {\n          callValuesListenersForChanges(1);\n        }\n        mutating = 0;\n        if (doRollback?.(store)) {\n          collForEach(changedCells, (table, tableId) =>\n            collForEach(table, (row, rowId) =>\n              collForEach(row, ([oldCell], cellId) =>\n                setOrDelCell(store, tableId, rowId, cellId, oldCell),\n              ),\n            ),\n          );\n          collClear(changedCells);\n          collForEach(changedValues, ([oldValue], valueId) =>\n            setOrDelValue(store, valueId, oldValue),\n          );\n          collClear(changedValues);\n        }\n        callListeners(finishTransactionListeners[0], void 0);\n        transactions = -1;\n        callInvalidCellListeners(0);\n        if (!collIsEmpty(changedCells)) {\n          callTabularListenersForChanges(0);\n        }\n        callInvalidValueListeners(0);\n        if (!collIsEmpty(changedValues)) {\n          callValuesListenersForChanges(0);\n        }\n        internalListeners[1]?.();\n        callListeners(finishTransactionListeners[1], void 0);\n        internalListeners[2]?.();\n        transactions = 0;\n        hadTables = hasTables();\n        hadValues = hasValues();\n        arrayForEach(\n          [\n            changedTableIds,\n            changedTableCellIds,\n            changedRowCount,\n            changedRowIds,\n            changedCellIds,\n            changedCells,\n            invalidCells,\n            changedValueIds,\n            changedValues,\n            invalidValues,\n          ],\n          collClear,\n        );\n      }\n    }\n    return store;\n  };\n  const forEachTable = (tableCallback) =>\n    collForEach(tablesMap, (tableMap, tableId) =>\n      tableCallback(tableId, (rowCallback) =>\n        collForEach(tableMap, (rowMap, rowId) =>\n          rowCallback(rowId, (cellCallback) =>\n            mapForEach(rowMap, cellCallback),\n          ),\n        ),\n      ),\n    );\n  const forEachTableCell = (tableId, tableCellCallback) =>\n    mapForEach(mapGet(tableCellIds, id(tableId)), tableCellCallback);\n  const forEachRow = (tableId, rowCallback) =>\n    collForEach(mapGet(tablesMap, id(tableId)), (rowMap, rowId) =>\n      rowCallback(rowId, (cellCallback) => mapForEach(rowMap, cellCallback)),\n    );\n  const forEachCell = (tableId, rowId, cellCallback) =>\n    mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);\n  const forEachValue = (valueCallback) => mapForEach(valuesMap, valueCallback);\n  const addSortedRowIdsListener = (\n    tableIdOrArgs,\n    cellIdOrListener,\n    descendingOrMutator,\n    offset,\n    limit,\n    listener,\n    mutator,\n  ) =>\n    isObject(tableIdOrArgs)\n      ? addSortedRowIdsListenerImpl(\n          tableIdOrArgs.tableId,\n          tableIdOrArgs.cellId,\n          [\n            tableIdOrArgs.descending ?? false,\n            tableIdOrArgs.offset ?? 0,\n            tableIdOrArgs.limit,\n          ],\n          cellIdOrListener,\n          descendingOrMutator,\n        )\n      : addSortedRowIdsListenerImpl(\n          tableIdOrArgs,\n          cellIdOrListener,\n          [descendingOrMutator, offset, limit],\n          listener,\n          mutator,\n        );\n  const addStartTransactionListener = (listener) =>\n    addListener(listener, startTransactionListeners);\n  const addWillFinishTransactionListener = (listener) =>\n    addListener(listener, finishTransactionListeners[0]);\n  const addDidFinishTransactionListener = (listener) =>\n    addListener(listener, finishTransactionListeners[1]);\n  const callListener = (listenerId) => {\n    callListenerImpl(listenerId);\n    return store;\n  };\n  const delListener = (listenerId) => {\n    delListenerImpl(listenerId);\n    return store;\n  };\n  const getListenerStats = () => ({\n    hasTables: pairCollSize2(hasTablesListeners),\n    tables: pairCollSize2(tablesListeners),\n    tableIds: pairCollSize2(tableIdsListeners),\n    hasTable: pairCollSize2(hasTableListeners),\n    table: pairCollSize2(tableListeners),\n    tableCellIds: pairCollSize2(tableCellIdsListeners),\n    hasTableCell: pairCollSize2(hasTableCellListeners, collSize3),\n    rowCount: pairCollSize2(rowCountListeners),\n    rowIds: pairCollSize2(rowIdsListeners),\n    sortedRowIds: pairCollSize2(sortedRowIdsListeners),\n    hasRow: pairCollSize2(hasRowListeners, collSize3),\n    row: pairCollSize2(rowListeners, collSize3),\n    cellIds: pairCollSize2(cellIdsListeners, collSize3),\n    hasCell: pairCollSize2(hasCellListeners, collSize4),\n    cell: pairCollSize2(cellListeners, collSize4),\n    invalidCell: pairCollSize2(invalidCellListeners, collSize4),\n    hasValues: pairCollSize2(hasValuesListeners),\n    values: pairCollSize2(valuesListeners),\n    valueIds: pairCollSize2(valueIdsListeners),\n    hasValue: pairCollSize2(hasValueListeners),\n    value: pairCollSize2(valueListeners),\n    invalidValue: pairCollSize2(invalidValueListeners),\n    transaction:\n      collSize2(startTransactionListeners) +\n      pairCollSize2(finishTransactionListeners),\n  });\n  const setInternalListeners = (\n    preStartTransaction,\n    preFinishTransaction,\n    postFinishTransaction,\n    cellChanged2,\n    valueChanged2,\n  ) =>\n    (internalListeners = [\n      preStartTransaction,\n      preFinishTransaction,\n      postFinishTransaction,\n      cellChanged2,\n      valueChanged2,\n    ]);\n  const store = {\n    getContent,\n    getTables,\n    getTableIds,\n    getTable,\n    getTableCellIds,\n    getRowCount,\n    getRowIds,\n    getSortedRowIds,\n    getRow,\n    getCellIds,\n    getCell,\n    getValues,\n    getValueIds,\n    getValue,\n    hasTables,\n    hasTable,\n    hasTableCell,\n    hasRow,\n    hasCell,\n    hasValues,\n    hasValue,\n    getTablesJson,\n    getValuesJson,\n    getJson,\n    getTablesSchemaJson,\n    getValuesSchemaJson,\n    getSchemaJson,\n    hasTablesSchema: () => hasTablesSchema,\n    hasValuesSchema: () => hasValuesSchema,\n    setContent,\n    setTables,\n    setTable,\n    setRow,\n    addRow,\n    setPartialRow,\n    setCell,\n    setValues,\n    setPartialValues,\n    setValue,\n    applyChanges,\n    setTablesJson,\n    setValuesJson,\n    setJson,\n    setTablesSchema,\n    setValuesSchema,\n    setSchema,\n    delTables,\n    delTable,\n    delRow,\n    delCell,\n    delValues,\n    delValue,\n    delTablesSchema,\n    delValuesSchema,\n    delSchema,\n    transaction,\n    startTransaction,\n    getTransactionChanges,\n    getTransactionLog,\n    finishTransaction,\n    forEachTable,\n    forEachTableCell,\n    forEachRow,\n    forEachCell,\n    forEachValue,\n    addSortedRowIdsListener,\n    addStartTransactionListener,\n    addWillFinishTransactionListener,\n    addDidFinishTransactionListener,\n    callListener,\n    delListener,\n    getListenerStats,\n    isMergeable: () => false,\n    // only used internally by other modules\n    createStore,\n    addListener,\n    callListeners,\n    setInternalListeners,\n  };\n  objMap(\n    {\n      [HAS + TABLES]: [0, hasTablesListeners, [], () => [hasTables()]],\n      [TABLES]: [0, tablesListeners],\n      [TABLE_IDS]: [0, tableIdsListeners],\n      [HAS + TABLE]: [\n        1,\n        hasTableListeners,\n        [getTableIds],\n        (ids) => [hasTable(...ids)],\n      ],\n      [TABLE]: [1, tableListeners, [getTableIds]],\n      [TABLE + CELL_IDS]: [1, tableCellIdsListeners, [getTableIds]],\n      [HAS + TABLE + CELL]: [\n        2,\n        hasTableCellListeners,\n        [getTableIds, getTableCellIds],\n        (ids) => [hasTableCell(...ids)],\n      ],\n      [ROW_COUNT]: [1, rowCountListeners, [getTableIds]],\n      [ROW_IDS]: [1, rowIdsListeners, [getTableIds]],\n      [HAS + ROW]: [\n        2,\n        hasRowListeners,\n        [getTableIds, getRowIds],\n        (ids) => [hasRow(...ids)],\n      ],\n      [ROW]: [2, rowListeners, [getTableIds, getRowIds]],\n      [CELL_IDS]: [2, cellIdsListeners, [getTableIds, getRowIds]],\n      [HAS + CELL]: [\n        3,\n        hasCellListeners,\n        [getTableIds, getRowIds, getCellIds],\n        (ids) => [hasCell(...ids)],\n      ],\n      [CELL]: [\n        3,\n        cellListeners,\n        [getTableIds, getRowIds, getCellIds],\n        (ids) => pairNew(getCell(...ids)),\n      ],\n      InvalidCell: [3, invalidCellListeners],\n      [HAS + VALUES]: [0, hasValuesListeners, [], () => [hasValues()]],\n      [VALUES]: [0, valuesListeners],\n      [VALUE_IDS]: [0, valueIdsListeners],\n      [HAS + VALUE]: [\n        1,\n        hasValueListeners,\n        [getValueIds],\n        (ids) => [hasValue(...ids)],\n      ],\n      [VALUE]: [\n        1,\n        valueListeners,\n        [getValueIds],\n        (ids) => pairNew(getValue(ids[0])),\n      ],\n      InvalidValue: [1, invalidValueListeners],\n    },\n    ([argumentCount, idSetNode, pathGetters, extraArgsGetter], listenable) => {\n      store[ADD + listenable + LISTENER] = (...args) =>\n        addListener(\n          args[argumentCount],\n          idSetNode[args[argumentCount + 1] ? 1 : 0],\n          argumentCount > 0 ? slice(args, 0, argumentCount) : void 0,\n          pathGetters,\n          extraArgsGetter,\n        );\n    },\n  );\n  return objFreeze(store);\n};\n\nconst LISTENER_ARGS = {\n  HasTable: 1,\n  Table: 1,\n  TableCellIds: 1,\n  HasTableCell: 2,\n  RowCount: 1,\n  RowIds: 1,\n  SortedRowIds: 5,\n  HasRow: 2,\n  Row: 2,\n  CellIds: 2,\n  HasCell: 3,\n  Cell: 3,\n  HasValue: 1,\n  Value: 1,\n  InvalidCell: 3,\n  InvalidValue: 1,\n};\nconst newContentStampMap = (time = EMPTY_STRING) => [\n  stampNewMap(time),\n  stampNewMap(time),\n];\nconst validateMergeableContent = (mergeableContent) =>\n  isArray(mergeableContent) &&\n  size(mergeableContent) == 2 &&\n  stampValidate(mergeableContent[0], (tableStamps) =>\n    objValidate(\n      tableStamps,\n      (tableStamp) =>\n        stampValidate(tableStamp, (rowStamps) =>\n          objValidate(\n            rowStamps,\n            (rowStamp) =>\n              stampValidate(rowStamp, (cellStamps) =>\n                objValidate(\n                  cellStamps,\n                  (cellStamp) =>\n                    stampValidate(cellStamp, isCellOrValueOrUndefined),\n                  void 0,\n                  1,\n                ),\n              ),\n            void 0,\n            1,\n          ),\n        ),\n      void 0,\n      1,\n    ),\n  ) &&\n  stampValidate(mergeableContent[1], (values) =>\n    objValidate(\n      values,\n      (value) => stampValidate(value, isCellOrValueOrUndefined),\n      void 0,\n      1,\n    ),\n  );\nconst createMergeableStore = (uniqueId, getNow) => {\n  let listeningToRawStoreChanges = 1;\n  let contentStampMap = newContentStampMap();\n  let defaultingContent = 0;\n  let mutated = 0;\n  const touchedCells = mapNew();\n  const touchedValues = setNew();\n  const [getNextHlc, seenHlc] = getHlcFunctions(uniqueId, getNow);\n  const store = createStore();\n  const disableListeningToRawStoreChanges = (actions) => {\n    const wasListening = listeningToRawStoreChanges;\n    listeningToRawStoreChanges = 0;\n    actions();\n    listeningToRawStoreChanges = wasListening;\n    return mergeableStore;\n  };\n  const mergeContentOrChanges = (contentOrChanges, isContent = 0) => {\n    const tablesChanges = {};\n    const valuesChanges = {};\n    const [\n      [tablesObj, incomingTablesHlc = EMPTY_STRING, incomingTablesHash = 0],\n      values,\n    ] = contentOrChanges;\n    const [tablesStampMap, valuesStampMap] = contentStampMap;\n    const [tableStampMaps, oldTablesHlc, oldTablesHash] = tablesStampMap;\n    let tablesHash = isContent ? incomingTablesHash : oldTablesHash;\n    let tablesHlc = incomingTablesHlc;\n    objForEach(\n      tablesObj,\n      (\n        [rowsObj, incomingTableHlc = EMPTY_STRING, incomingTableHash = 0],\n        tableId,\n      ) => {\n        const tableStampMap = mapEnsure(tableStampMaps, tableId, stampNewMap);\n        const [rowStampMaps, oldTableHlc, oldTableHash] = tableStampMap;\n        let tableHash = isContent ? incomingTableHash : oldTableHash;\n        let tableHlc = incomingTableHlc;\n        objForEach(rowsObj, (row, rowId) => {\n          const [rowHlc, oldRowHash, rowHash] = mergeCellsOrValues(\n            row,\n            mapEnsure(rowStampMaps, rowId, stampNewMap),\n            objEnsure(objEnsure(tablesChanges, tableId, objNew), rowId, objNew),\n            isContent,\n          );\n          tableHash ^= isContent\n            ? 0\n            : addOrRemoveHash(\n                oldRowHash ? getValueInValuesHash(rowId, oldRowHash) : 0,\n                getValueInValuesHash(rowId, rowHash),\n              );\n          tableHlc = getLatestHlc(tableHlc, rowHlc);\n        });\n        tableHash ^= isContent\n          ? 0\n          : replaceHlcHash(oldTableHlc, incomingTableHlc);\n        stampUpdate(tableStampMap, incomingTableHlc, tableHash);\n        tablesHash ^= isContent\n          ? 0\n          : addOrRemoveHash(\n              oldTableHash ? getValueInValuesHash(tableId, oldTableHash) : 0,\n              getValueInValuesHash(tableId, tableStampMap[2]),\n            );\n        tablesHlc = getLatestHlc(tablesHlc, tableHlc);\n      },\n    );\n    tablesHash ^= isContent\n      ? 0\n      : replaceHlcHash(oldTablesHlc, incomingTablesHlc);\n    stampUpdate(tablesStampMap, incomingTablesHlc, tablesHash);\n    const [valuesHlc] = mergeCellsOrValues(\n      values,\n      valuesStampMap,\n      valuesChanges,\n      isContent,\n    );\n    seenHlc(getLatestHlc(tablesHlc, valuesHlc));\n    return [tablesChanges, valuesChanges, 1];\n  };\n  const mergeCellsOrValues = (\n    things,\n    thingsStampMap,\n    thingsChanges,\n    isContent,\n  ) => {\n    const [\n      thingsObj,\n      incomingThingsHlc = EMPTY_STRING,\n      incomingThingsHash = 0,\n    ] = things;\n    const [thingStampMaps, oldThingsHlc, oldThingsHash] = thingsStampMap;\n    let thingsHlc = incomingThingsHlc;\n    let thingsHash = isContent ? incomingThingsHash : oldThingsHash;\n    objForEach(\n      thingsObj,\n      ([thing, thingHlc = EMPTY_STRING, incomingThingHash = 0], thingId) => {\n        const thingStampMap = mapEnsure(thingStampMaps, thingId, () => [\n          void 0,\n          EMPTY_STRING,\n          0,\n        ]);\n        const [, oldThingHlc, oldThingHash] = thingStampMap;\n        if (!oldThingHlc || thingHlc > oldThingHlc) {\n          stampUpdate(\n            thingStampMap,\n            thingHlc,\n            isContent ? incomingThingHash : getValueHash(thing, thingHlc),\n          );\n          thingStampMap[0] = thing;\n          thingsChanges[thingId] = thing;\n          thingsHash ^= isContent\n            ? 0\n            : addOrRemoveHash(\n                getValueInValuesHash(thingId, oldThingHash),\n                getValueInValuesHash(thingId, thingStampMap[2]),\n              );\n          thingsHlc = getLatestHlc(thingsHlc, thingHlc);\n        }\n      },\n    );\n    thingsHash ^= isContent\n      ? 0\n      : replaceHlcHash(oldThingsHlc, incomingThingsHlc);\n    stampUpdate(thingsStampMap, incomingThingsHlc, thingsHash);\n    return [thingsHlc, oldThingsHash, thingsStampMap[2]];\n  };\n  const preStartTransaction = noop;\n  const preFinishTransaction = noop;\n  const postFinishTransaction = () => {\n    collClear(touchedCells);\n    collClear(touchedValues);\n  };\n  const cellChanged = (tableId, rowId, cellId, newCell, mutating) => {\n    setAdd(\n      mapEnsure(mapEnsure(touchedCells, tableId, mapNew), rowId, setNew),\n      cellId,\n    );\n    if (listeningToRawStoreChanges || mutating) {\n      if (mutating) {\n        mutated = 1;\n      }\n      mergeContentOrChanges([\n        [\n          {\n            [tableId]: [\n              {\n                [rowId]: [\n                  {\n                    [cellId]: [\n                      newCell,\n                      defaultingContent ? EMPTY_STRING : getNextHlc(),\n                    ],\n                  },\n                ],\n              },\n            ],\n          },\n        ],\n        [{}],\n        1,\n      ]);\n    }\n  };\n  const valueChanged = (valueId, newValue, mutating) => {\n    setAdd(touchedValues, valueId);\n    if (listeningToRawStoreChanges || mutating) {\n      if (mutating) {\n        mutated = 1;\n      }\n      mergeContentOrChanges([\n        [{}],\n        [\n          {\n            [valueId]: [\n              newValue,\n              defaultingContent ? EMPTY_STRING : getNextHlc(),\n            ],\n          },\n        ],\n        1,\n      ]);\n    }\n  };\n  const getMergeableContent = () => [\n    stampMapToObjWithHash(contentStampMap[0], (tableStampMap) =>\n      stampMapToObjWithHash(tableStampMap, (rowStampMap) =>\n        stampMapToObjWithHash(rowStampMap),\n      ),\n    ),\n    stampMapToObjWithHash(contentStampMap[1]),\n  ];\n  const getMergeableContentHashes = () => [\n    contentStampMap[0][2],\n    contentStampMap[1][2],\n  ];\n  const getMergeableTableHashes = () =>\n    mapToObj(contentStampMap[0][0], getStampHash);\n  const getMergeableTableDiff = (otherTableHashes) => {\n    const newTables = stampNewObj(contentStampMap[0][1]);\n    const differingTableHashes = {};\n    mapForEach(\n      contentStampMap[0][0],\n      (tableId, [tableStampMap, tableHlc, hash]) =>\n        objHas(otherTableHashes, tableId)\n          ? hash != otherTableHashes[tableId]\n            ? (differingTableHashes[tableId] = hash)\n            : 0\n          : (newTables[0][tableId] = stampMapToObjWithoutHash(\n              [tableStampMap, tableHlc],\n              (rowStampMap) => stampMapToObjWithoutHash(rowStampMap),\n            )),\n    );\n    return [newTables, differingTableHashes];\n  };\n  const getMergeableRowHashes = (otherTableHashes) => {\n    const rowHashes = {};\n    objForEach(otherTableHashes, (otherTableHash, tableId) =>\n      ifNotUndefined(\n        mapGet(contentStampMap[0][0], tableId),\n        ([rowStampMaps, , tableHash]) =>\n          tableHash != otherTableHash\n            ? mapForEach(\n                rowStampMaps,\n                (rowId, [, , rowHash]) =>\n                  (objEnsure(rowHashes, tableId, objNew)[rowId] = rowHash),\n              )\n            : 0,\n      ),\n    );\n    return rowHashes;\n  };\n  const getMergeableRowDiff = (otherTableRowHashes) => {\n    const newRows = stampNewObj(contentStampMap[0][1]);\n    const differingRowHashes = {};\n    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>\n      mapForEach(\n        mapGet(contentStampMap[0][0], tableId)?.[0],\n        (rowId, [rowStampMap, rowHlc, hash]) =>\n          objHas(otherRowHashes, rowId)\n            ? hash !== otherRowHashes[rowId]\n              ? (objEnsure(differingRowHashes, tableId, objNew)[rowId] = hash)\n              : 0\n            : (objEnsure(newRows[0], tableId, stampNewObj)[0][rowId] =\n                stampMapToObjWithoutHash([rowStampMap, rowHlc])),\n      ),\n    );\n    return [newRows, differingRowHashes];\n  };\n  const getMergeableCellHashes = (otherTableRowHashes) => {\n    const cellHashes = {};\n    objForEach(otherTableRowHashes, (otherRowHashes, tableId) =>\n      ifNotUndefined(mapGet(contentStampMap[0][0], tableId), ([rowStampMaps]) =>\n        objForEach(otherRowHashes, (otherRowHash, rowId) =>\n          ifNotUndefined(\n            mapGet(rowStampMaps, rowId),\n            ([cellStampMaps, , rowHash]) =>\n              rowHash !== otherRowHash\n                ? mapForEach(\n                    cellStampMaps,\n                    (cellId, [, , cellHash]) =>\n                      (objEnsure(\n                        objEnsure(cellHashes, tableId, objNew),\n                        rowId,\n                        objNew,\n                      )[cellId] = cellHash),\n                  )\n                : 0,\n          ),\n        ),\n      ),\n    );\n    return cellHashes;\n  };\n  const getMergeableCellDiff = (otherTableRowCellHashes) => {\n    const [[tableStampMaps, tablesHlc]] = contentStampMap;\n    const tablesObj = {};\n    objForEach(otherTableRowCellHashes, (otherRowCellHashes, tableId) =>\n      objForEach(otherRowCellHashes, (otherCellHashes, rowId) =>\n        ifNotUndefined(\n          mapGet(tableStampMaps, tableId),\n          ([rowStampMaps, tableHlc]) =>\n            ifNotUndefined(\n              mapGet(rowStampMaps, rowId),\n              ([cellStampMaps, rowHlc]) =>\n                mapForEach(cellStampMaps, (cellId, [cell, cellHlc, hash]) =>\n                  hash !== otherCellHashes[cellId]\n                    ? (objEnsure(\n                        objEnsure(tablesObj, tableId, () =>\n                          stampNewObj(tableHlc),\n                        )[0],\n                        rowId,\n                        () => stampNewObj(rowHlc),\n                      )[0][cellId] = [cell, cellHlc])\n                    : 0,\n                ),\n            ),\n        ),\n      ),\n    );\n    return stampNew(tablesObj, tablesHlc);\n  };\n  const getMergeableValueHashes = () =>\n    mapToObj(contentStampMap[1][0], getStampHash);\n  const getMergeableValueDiff = (otherValueHashes) => {\n    const [, [valueStampMaps, valuesHlc]] = contentStampMap;\n    const values = mapToObj(\n      valueStampMaps,\n      stampClone,\n      ([, , hash], valueId) => hash == otherValueHashes?.[valueId],\n    );\n    return stampNew(values, valuesHlc);\n  };\n  const setMergeableContent = (mergeableContent) =>\n    disableListeningToRawStoreChanges(() =>\n      validateMergeableContent(mergeableContent)\n        ? store.transaction(() => {\n            store.delTables().delValues();\n            contentStampMap = newContentStampMap();\n            store.applyChanges(mergeContentOrChanges(mergeableContent, 1));\n          })\n        : 0,\n    );\n  const setDefaultContent = (content) => {\n    store.transaction(() => {\n      defaultingContent = 1;\n      store.setContent(content);\n      defaultingContent = 0;\n    });\n    return mergeableStore;\n  };\n  const getTransactionMergeableChanges = (withHashes = false) => {\n    const [\n      [tableStampMaps, tablesHlc, tablesHash],\n      [valueStampMaps, valuesHlc, valuesHash],\n    ] = contentStampMap;\n    const newStamp = withHashes ? stampNewWithHash : stampNew;\n    const tablesObj = {};\n    collForEach(touchedCells, (touchedTable, tableId) =>\n      ifNotUndefined(\n        mapGet(tableStampMaps, tableId),\n        ([rowStampMaps, tableHlc, tableHash]) => {\n          const tableObj = {};\n          collForEach(touchedTable, (touchedRow, rowId) =>\n            ifNotUndefined(\n              mapGet(rowStampMaps, rowId),\n              ([cellStampMaps, rowHlc, rowHash]) => {\n                const rowObj = {};\n                collForEach(touchedRow, (cellId) => {\n                  ifNotUndefined(\n                    mapGet(cellStampMaps, cellId),\n                    ([cell, time, hash]) =>\n                      (rowObj[cellId] = newStamp(cell, time, hash)),\n                  );\n                });\n                tableObj[rowId] = newStamp(rowObj, rowHlc, rowHash);\n              },\n            ),\n          );\n          tablesObj[tableId] = newStamp(tableObj, tableHlc, tableHash);\n        },\n      ),\n    );\n    const valuesObj = {};\n    collForEach(touchedValues, (valueId) =>\n      ifNotUndefined(\n        mapGet(valueStampMaps, valueId),\n        ([value, time, hash]) =>\n          (valuesObj[valueId] = newStamp(value, time, hash)),\n      ),\n    );\n    return [\n      newStamp(tablesObj, tablesHlc, tablesHash),\n      newStamp(valuesObj, valuesHlc, valuesHash),\n      1,\n    ];\n  };\n  const applyMergeableChanges = (mergeableChanges) =>\n    disableListeningToRawStoreChanges(() =>\n      store.applyChanges(mergeContentOrChanges(mergeableChanges)),\n    );\n  const merge = (mergeableStore2) => {\n    const mergeableChanges = getMergeableContent();\n    const mergeableChanges2 = mergeableStore2.getMergeableContent();\n    mergeableStore2.applyMergeableChanges(mergeableChanges);\n    return applyMergeableChanges(mergeableChanges2);\n  };\n  const hadMutated = () => {\n    const result = mutated;\n    mutated = 0;\n    return result;\n  };\n  const mergeableStore = {\n    getMergeableContent,\n    getMergeableContentHashes,\n    getMergeableTableHashes,\n    getMergeableTableDiff,\n    getMergeableRowHashes,\n    getMergeableRowDiff,\n    getMergeableCellHashes,\n    getMergeableCellDiff,\n    getMergeableValueHashes,\n    getMergeableValueDiff,\n    setMergeableContent,\n    setDefaultContent,\n    getTransactionMergeableChanges,\n    applyMergeableChanges,\n    merge,\n    // only used internally by other modules\n    hadMutated,\n  };\n  store.setInternalListeners(\n    preStartTransaction,\n    preFinishTransaction,\n    postFinishTransaction,\n    cellChanged,\n    valueChanged,\n  );\n  objMap(\n    store,\n    (method, name) =>\n      (mergeableStore[name] = // fluent methods\n        strStartsWith(name, SET) ||\n        strStartsWith(name, DEL) ||\n        strStartsWith(name, 'apply') ||\n        strEndsWith(name, TRANSACTION) ||\n        name == 'call' + LISTENER\n          ? (...args) => {\n              method(...args);\n              return mergeableStore;\n            }\n          : strStartsWith(name, ADD) && strEndsWith(name, LISTENER)\n            ? (...args) => {\n                const listenerArg = LISTENER_ARGS[slice(name, 3, -8)] ?? 0;\n                const listener = args[listenerArg];\n                args[listenerArg] = (_store, ...args2) =>\n                  listener(mergeableStore, ...args2);\n                return method(...args);\n              }\n            : name == 'isMergeable'\n              ? () => true\n              : method),\n  );\n  return objFreeze(mergeableStore);\n};\n\nconst numericAggregators = /* @__PURE__ */ mapNew([\n  [\n    AVG,\n    [\n      (numbers, length) => arraySum(numbers) / length,\n      (metric, add, length) => metric + (add - metric) / (length + 1),\n      (metric, remove, length) => metric + (metric - remove) / (length - 1),\n      (metric, add, remove, length) => metric + (add - remove) / length,\n    ],\n  ],\n  [\n    MAX,\n    [\n      (numbers) => mathMax(...numbers),\n      (metric, add) => mathMax(add, metric),\n      (metric, remove) => (remove == metric ? void 0 : metric),\n      (metric, add, remove) =>\n        remove == metric ? void 0 : mathMax(add, metric),\n    ],\n  ],\n  [\n    MIN,\n    [\n      (numbers) => mathMin(...numbers),\n      (metric, add) => mathMin(add, metric),\n      (metric, remove) => (remove == metric ? void 0 : metric),\n      (metric, add, remove) =>\n        remove == metric ? void 0 : mathMin(add, metric),\n    ],\n  ],\n  [\n    SUM,\n    [\n      (numbers) => arraySum(numbers),\n      (metric, add) => metric + add,\n      (metric, remove) => metric - remove,\n      (metric, add, remove) => metric - remove + add,\n    ],\n  ],\n]);\nconst getAggregateValue = (\n  aggregateValue,\n  oldLength,\n  newValues,\n  changedValues,\n  aggregators,\n  force = false,\n) => {\n  if (collIsEmpty(newValues)) {\n    return void 0;\n  }\n  const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =\n    aggregators;\n  force ||= isUndefined(aggregateValue);\n  collForEach(changedValues, ([oldValue, newValue]) => {\n    if (!force) {\n      aggregateValue = isUndefined(oldValue)\n        ? aggregateAdd?.(aggregateValue, newValue, oldLength++)\n        : isUndefined(newValue)\n          ? aggregateRemove?.(aggregateValue, oldValue, oldLength--)\n          : aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);\n      force ||= isUndefined(aggregateValue);\n    }\n  });\n  return force\n    ? aggregate(collValues(newValues), collSize(newValues))\n    : aggregateValue;\n};\n\nconst createMetrics = getCreateFunction((store) => {\n  const metricListeners = mapNew();\n  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(\n    () => metrics,\n  );\n  const [\n    getStore,\n    getMetricIds,\n    forEachMetric,\n    hasMetric,\n    getTableId,\n    getMetric,\n    setMetric,\n    ,\n    setDefinitionAndListen,\n    delDefinition,\n    addMetricIdsListener,\n    destroy,\n  ] = getDefinableFunctions(\n    store,\n    getUndefined,\n    (value) =>\n      isNaN(value) ||\n      isUndefined(value) ||\n      isTrue(value) ||\n      isFalse(value) ||\n      value === EMPTY_STRING\n        ? void 0\n        : value * 1,\n    addListener,\n    callListeners,\n  );\n  const setMetricDefinition = (\n    metricId,\n    tableId,\n    aggregate,\n    getNumber,\n    aggregateAdd,\n    aggregateRemove,\n    aggregateReplace,\n  ) => {\n    const aggregators = isFunction(aggregate)\n      ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]\n      : (mapGet(numericAggregators, aggregate) ??\n        mapGet(numericAggregators, SUM));\n    setDefinitionAndListen(\n      metricId,\n      tableId,\n      (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {\n        const oldMetric = getMetric(metricId);\n        const oldLength = collSize(numbers);\n        force ||= isUndefined(oldMetric);\n        change();\n        let newMetric = getAggregateValue(\n          oldMetric,\n          oldLength,\n          numbers,\n          changedNumbers,\n          aggregators,\n          force,\n        );\n        if (!isFiniteNumber(newMetric)) {\n          newMetric = void 0;\n        }\n        if (newMetric != oldMetric) {\n          setMetric(metricId, newMetric);\n          callListeners(metricListeners, [metricId], newMetric, oldMetric);\n        }\n      },\n      getRowCellFunction(getNumber, 1),\n    );\n    return metrics;\n  };\n  const delMetricDefinition = (metricId) => {\n    delDefinition(metricId);\n    return metrics;\n  };\n  const addMetricListener = (metricId, listener) =>\n    addListener(listener, metricListeners, [metricId]);\n  const delListener = (listenerId) => {\n    delListenerImpl(listenerId);\n    return metrics;\n  };\n  const getListenerStats = () => ({\n    metric: collSize2(metricListeners),\n  });\n  const metrics = {\n    setMetricDefinition,\n    delMetricDefinition,\n    getStore,\n    getMetricIds,\n    forEachMetric,\n    hasMetric,\n    getTableId,\n    getMetric,\n    addMetricIdsListener,\n    addMetricListener,\n    delListener,\n    destroy,\n    getListenerStats,\n  };\n  return objFreeze(metrics);\n});\n\nconst createQueries = getCreateFunction((store) => {\n  const createStore = store.createStore;\n  const preStore = createStore();\n  const resultStore = createStore();\n  const preStoreListenerIds = mapNew();\n  const paramValuesListeners = mapNew();\n  const paramValueListeners = mapNew();\n  const {\n    addListener,\n    callListeners,\n    delListener: delListenerImpl,\n  } = resultStore;\n  const [\n    getStore,\n    getQueryIds,\n    forEachQuery,\n    hasQuery,\n    getTableId,\n    getQueryArgs,\n    setQueryArgs,\n    setDefinition,\n    ,\n    delDefinition,\n    addQueryIdsListenerImpl,\n    destroy,\n    addStoreListeners,\n    delStoreListeners,\n  ] = getDefinableFunctions(\n    store,\n    () => [],\n    getUndefined,\n    addListener,\n    callListeners,\n  );\n  const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>\n    arrayForEach(listenerIds, (listenerId) =>\n      setAdd(\n        mapEnsure(\n          mapEnsure(preStoreListenerIds, queryId, mapNew),\n          preStore2,\n          setNew,\n        ),\n        listenerId,\n      ),\n    );\n  const resetPreStores = (queryId) => {\n    ifNotUndefined(\n      mapGet(preStoreListenerIds, queryId),\n      (queryPreStoreListenerIds) => {\n        mapForEach(queryPreStoreListenerIds, (preStore2, listenerIds) =>\n          collForEach(listenerIds, (listenerId) =>\n            preStore2.delListener(listenerId),\n          ),\n        );\n        collClear(queryPreStoreListenerIds);\n      },\n    );\n    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));\n  };\n  const synchronizeTransactions = (queryId, fromStore, toStore) =>\n    addPreStoreListener(\n      fromStore,\n      queryId,\n      fromStore.addStartTransactionListener(toStore.startTransaction),\n      fromStore.addDidFinishTransactionListener(() =>\n        toStore.finishTransaction(),\n      ),\n    );\n  const setQueryDefinition = (queryId, tableId, build, paramValues = {}) => {\n    const oldParamValues = getParamValues(queryId);\n    setDefinition(queryId, tableId);\n    setQueryArgs(queryId, [build, objToMap(paramValues)]);\n    callParamListeners(queryId, oldParamValues, paramValues);\n    resetPreStores(queryId);\n    const [, paramsMap] = getQueryArgs(queryId);\n    const selectEntries = [];\n    const joinEntries = [[void 0, [tableId, void 0, void 0, [], mapNew()]]];\n    const wheres = [];\n    const groupEntries = [];\n    const havings = [];\n    const param = (paramId) => mapGet(paramsMap, paramId);\n    const select = (arg1, arg2) => {\n      const selectEntry = isFunction(arg1)\n        ? [size(selectEntries) + EMPTY_STRING, arg1]\n        : [\n            isUndefined(arg2) ? arg1 : arg2,\n            (getTableCell) => getTableCell(arg1, arg2),\n          ];\n      arrayPush(selectEntries, selectEntry);\n      return {as: (selectedCellId) => (selectEntry[0] = selectedCellId)};\n    };\n    const join = (joinedTableId, arg1, arg2) => {\n      const fromIntermediateJoinedTableId =\n        isUndefined(arg2) || isFunction(arg1) ? void 0 : arg1;\n      const onArg = isUndefined(fromIntermediateJoinedTableId) ? arg1 : arg2;\n      const joinEntry = [\n        joinedTableId,\n        [\n          joinedTableId,\n          fromIntermediateJoinedTableId,\n          isFunction(onArg) ? onArg : (getCell) => getCell(onArg),\n          [],\n          mapNew(),\n        ],\n      ];\n      arrayPush(joinEntries, joinEntry);\n      return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};\n    };\n    const where = (arg1, arg2, arg3) =>\n      arrayPush(\n        wheres,\n        isFunction(arg1)\n          ? arg1\n          : isUndefined(arg3)\n            ? (getTableCell) => getTableCell(arg1) === arg2\n            : (getTableCell) => getTableCell(arg1, arg2) === arg3,\n      );\n    const group = (\n      selectedCellId,\n      aggregate,\n      aggregateAdd,\n      aggregateRemove,\n      aggregateReplace,\n    ) => {\n      const groupEntry = [\n        selectedCellId,\n        [\n          selectedCellId,\n          isFunction(aggregate)\n            ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]\n            : (mapGet(numericAggregators, aggregate) ?? [\n                (_cells, length) => length,\n              ]),\n        ],\n      ];\n      arrayPush(groupEntries, groupEntry);\n      return {as: (groupedCellId) => (groupEntry[0] = groupedCellId)};\n    };\n    const having = (arg1, arg2) =>\n      arrayPush(\n        havings,\n        isFunction(arg1)\n          ? arg1\n          : (getSelectedOrGroupedCell) =>\n              getSelectedOrGroupedCell(arg1) === arg2,\n      );\n    build({select, join, where, group, having, param});\n    const selects = mapNew(selectEntries);\n    if (collIsEmpty(selects)) {\n      return queries;\n    }\n    const joins = mapNew(joinEntries);\n    mapForEach(joins, (asTableId, [, fromAsTableId]) =>\n      ifNotUndefined(mapGet(joins, fromAsTableId), ({3: toAsTableIds}) =>\n        isUndefined(asTableId) ? 0 : arrayPush(toAsTableIds, asTableId),\n      ),\n    );\n    const groups = mapNew(groupEntries);\n    let selectJoinWhereStore = preStore;\n    if (collIsEmpty(groups) && arrayIsEmpty(havings)) {\n      selectJoinWhereStore = resultStore;\n    } else {\n      synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);\n      const groupedSelectedCellIds = mapNew();\n      mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>\n        setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [\n          groupedCellId,\n          aggregators,\n        ]),\n      );\n      const groupBySelectedCellIds = setNew();\n      mapForEach(selects, (selectedCellId) =>\n        collHas(groupedSelectedCellIds, selectedCellId)\n          ? 0\n          : setAdd(groupBySelectedCellIds, selectedCellId),\n      );\n      const tree = mapNew();\n      const writeGroupRow = (\n        leaf,\n        changedGroupedSelectedCells,\n        selectedRowId,\n        forceRemove,\n      ) =>\n        ifNotUndefined(\n          leaf,\n          ([selectedCells, selectedRowIds, groupRowId, groupRow]) => {\n            mapForEach(\n              changedGroupedSelectedCells,\n              (selectedCellId, [newCell]) => {\n                const selectedCell = mapEnsure(\n                  selectedCells,\n                  selectedCellId,\n                  mapNew,\n                );\n                const oldLeafCell = mapGet(selectedCell, selectedRowId);\n                const newLeafCell = forceRemove ? void 0 : newCell;\n                if (oldLeafCell !== newLeafCell) {\n                  const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);\n                  const oldLength = collSize(selectedCell);\n                  mapSet(selectedCell, selectedRowId, newLeafCell);\n                  collForEach(\n                    mapGet(groupedSelectedCellIds, selectedCellId),\n                    ([groupedCellId, aggregators]) => {\n                      const aggregateValue = getAggregateValue(\n                        groupRow[groupedCellId],\n                        oldLength,\n                        selectedCell,\n                        oldNewSet,\n                        aggregators,\n                      );\n                      groupRow[groupedCellId] = isUndefined(\n                        getCellOrValueType(aggregateValue),\n                      )\n                        ? void 0\n                        : aggregateValue;\n                    },\n                  );\n                }\n              },\n            );\n            if (\n              collIsEmpty(selectedRowIds) ||\n              !arrayEvery(havings, (having2) =>\n                having2((cellId) => groupRow[cellId]),\n              )\n            ) {\n              resultStore.delRow(queryId, groupRowId);\n            } else if (isUndefined(groupRowId)) {\n              leaf[2] = resultStore.addRow(queryId, groupRow);\n            } else {\n              resultStore.setRow(queryId, groupRowId, groupRow);\n            }\n          },\n        );\n      addPreStoreListener(\n        selectJoinWhereStore,\n        queryId,\n        selectJoinWhereStore.addRowListener(\n          queryId,\n          null,\n          (_store, _tableId, selectedRowId, getCellChange) => {\n            const oldPath = [];\n            const newPath = [];\n            const changedGroupedSelectedCells = mapNew();\n            const rowExists = selectJoinWhereStore.hasRow(\n              queryId,\n              selectedRowId,\n            );\n            let changedLeaf = !rowExists;\n            collForEach(groupBySelectedCellIds, (selectedCellId) => {\n              const [changed, oldCell, newCell] = getCellChange(\n                queryId,\n                selectedRowId,\n                selectedCellId,\n              );\n              arrayPush(oldPath, oldCell);\n              arrayPush(newPath, newCell);\n              changedLeaf ||= changed;\n            });\n            mapForEach(groupedSelectedCellIds, (selectedCellId) => {\n              const [changed, , newCell] = getCellChange(\n                queryId,\n                selectedRowId,\n                selectedCellId,\n              );\n              if (changedLeaf || changed) {\n                mapSet(changedGroupedSelectedCells, selectedCellId, [newCell]);\n              }\n            });\n            if (changedLeaf) {\n              writeGroupRow(\n                visitTree(tree, oldPath, void 0, ([, selectedRowIds]) => {\n                  collDel(selectedRowIds, selectedRowId);\n                  return collIsEmpty(selectedRowIds);\n                }),\n                changedGroupedSelectedCells,\n                selectedRowId,\n                1,\n              );\n            }\n            if (rowExists) {\n              writeGroupRow(\n                visitTree(\n                  tree,\n                  newPath,\n                  () => {\n                    const groupRow = {};\n                    collForEach(\n                      groupBySelectedCellIds,\n                      (selectedCellId) =>\n                        (groupRow[selectedCellId] =\n                          selectJoinWhereStore.getCell(\n                            queryId,\n                            selectedRowId,\n                            selectedCellId,\n                          )),\n                    );\n                    return [mapNew(), setNew(), void 0, groupRow];\n                  },\n                  ([, selectedRowIds]) => {\n                    setAdd(selectedRowIds, selectedRowId);\n                  },\n                ),\n                changedGroupedSelectedCells,\n                selectedRowId,\n              );\n            }\n          },\n        ),\n      );\n    }\n    synchronizeTransactions(queryId, store, selectJoinWhereStore);\n    const writeSelectRow = (rootRowId) => {\n      const getTableCell = (arg1, arg2) =>\n        store.getCell(\n          ...(isUndefined(arg2)\n            ? [tableId, rootRowId, arg1]\n            : arg1 === tableId\n              ? [tableId, rootRowId, arg2]\n              : [\n                  mapGet(joins, arg1)?.[0],\n                  mapGet(mapGet(joins, arg1)?.[4], rootRowId)?.[0],\n                  arg2,\n                ]),\n        );\n      selectJoinWhereStore.transaction(() =>\n        arrayEvery(wheres, (where2) => where2(getTableCell))\n          ? mapForEach(selects, (asCellId, tableCellGetter) =>\n              setOrDelCell(\n                selectJoinWhereStore,\n                queryId,\n                rootRowId,\n                asCellId,\n                tableCellGetter(getTableCell, rootRowId),\n              ),\n            )\n          : selectJoinWhereStore.delRow(queryId, rootRowId),\n      );\n    };\n    const listenToTable = (rootRowId, tableId2, rowId, joinedTableIds2) => {\n      const getCell = (cellId) => store.getCell(tableId2, rowId, cellId);\n      arrayForEach(joinedTableIds2, (remoteAsTableId) => {\n        const [realJoinedTableId, , on, nextJoinedTableIds, remoteIdPairs] =\n          mapGet(joins, remoteAsTableId);\n        const remoteRowId = on?.(getCell, rootRowId);\n        const [previousRemoteRowId, previousRemoteListenerId] =\n          mapGet(remoteIdPairs, rootRowId) ?? [];\n        if (remoteRowId != previousRemoteRowId) {\n          if (!isUndefined(previousRemoteListenerId)) {\n            delStoreListeners(queryId, previousRemoteListenerId);\n          }\n          mapSet(\n            remoteIdPairs,\n            rootRowId,\n            isUndefined(remoteRowId)\n              ? void 0\n              : [\n                  remoteRowId,\n                  ...addStoreListeners(\n                    queryId,\n                    1,\n                    store.addRowListener(realJoinedTableId, remoteRowId, () =>\n                      listenToTable(\n                        rootRowId,\n                        realJoinedTableId,\n                        remoteRowId,\n                        nextJoinedTableIds,\n                      ),\n                    ),\n                  ),\n                ],\n          );\n        }\n      });\n      writeSelectRow(rootRowId);\n    };\n    const {3: joinedTableIds} = mapGet(joins, void 0);\n    selectJoinWhereStore.transaction(() =>\n      addStoreListeners(\n        queryId,\n        1,\n        store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {\n          if (store.hasRow(tableId, rootRowId)) {\n            listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);\n          } else {\n            selectJoinWhereStore.delRow(queryId, rootRowId);\n            collForEach(joins, ({4: idsByRootRowId}) =>\n              ifNotUndefined(\n                mapGet(idsByRootRowId, rootRowId),\n                ([, listenerId]) => {\n                  delStoreListeners(queryId, listenerId);\n                  mapSet(idsByRootRowId, rootRowId);\n                },\n              ),\n            );\n          }\n        }),\n      ),\n    );\n    return queries;\n  };\n  const callParamListeners = (queryId, oldParamValues, newParamValues) => {\n    const allParamIds = setNew([\n      ...objIds(oldParamValues),\n      ...objIds(newParamValues),\n    ]);\n    let changed = 0;\n    collForEach(allParamIds, (paramId) => {\n      const newParamValue = objGet(newParamValues, paramId);\n      if (!arrayOrValueEqual(objGet(oldParamValues, paramId), newParamValue)) {\n        changed = 1;\n        callListeners(paramValueListeners, [queryId, paramId], newParamValue);\n      }\n    });\n    if (changed) {\n      callListeners(paramValuesListeners, [queryId], newParamValues);\n    }\n  };\n  const delQueryDefinition = (queryId) => {\n    const oldParamValues = getParamValues(queryId);\n    resetPreStores(queryId);\n    delDefinition(queryId);\n    callParamListeners(queryId, oldParamValues, {});\n    return queries;\n  };\n  const setParamValues = (queryId, paramValues, force = 0) => {\n    ifNotUndefined(getQueryArgs(queryId), ([definition, oldParamValues]) => {\n      if (\n        force ||\n        !objIsEqual(mapToObj(oldParamValues), paramValues, arrayOrValueEqual)\n      ) {\n        resultStore.transaction(() =>\n          setQueryDefinition(\n            queryId,\n            getTableId(queryId),\n            definition,\n            paramValues,\n          ),\n        );\n      }\n    });\n    return queries;\n  };\n  const setParamValue = (queryId, paramId, value) => {\n    if (!arrayOrValueEqual(getParamValue(queryId, paramId), value)) {\n      setParamValues(\n        queryId,\n        {...getParamValues(queryId), [paramId]: value},\n        1,\n      );\n    }\n    return queries;\n  };\n  const getParamValues = (queryId) => mapToObj(getQueryArgs(queryId)?.[1]);\n  const getParamValue = (queryId, paramId) =>\n    mapGet(getQueryArgs(queryId)?.[1], paramId);\n  const addQueryIdsListener = (listener) =>\n    addQueryIdsListenerImpl(() => listener(queries));\n  const addParamValuesListener = (queryId, listener) =>\n    addListener(\n      (_, queryId2, paramValues) => listener(queries, queryId2, paramValues),\n      paramValuesListeners,\n      [queryId],\n    );\n  const addParamValueListener = (queryId, paramId, listener) =>\n    addListener(\n      (_, queryId2, paramId2, paramValue) =>\n        listener(queries, queryId2, paramId2, paramValue),\n      paramValueListeners,\n      [queryId, paramId],\n    );\n  const delListener = (listenerId) => {\n    delListenerImpl(listenerId);\n    return queries;\n  };\n  const getListenerStats = () => {\n    const {\n      tables: _1,\n      tableIds: _2,\n      transaction: _3,\n      ...stats\n    } = resultStore.getListenerStats();\n    return {\n      ...stats,\n      paramValues: collSize2(paramValuesListeners),\n      paramValue: collSize3(paramValueListeners),\n    };\n  };\n  const queries = {\n    setQueryDefinition,\n    delQueryDefinition,\n    getParamValues,\n    getParamValue,\n    setParamValues,\n    setParamValue,\n    getStore,\n    getQueryIds,\n    forEachQuery,\n    hasQuery,\n    getTableId,\n    addQueryIdsListener,\n    addParamValuesListener,\n    addParamValueListener,\n    delListener,\n    destroy,\n    getListenerStats,\n  };\n  objMap(\n    {\n      [TABLE]: [1, 1],\n      [TABLE + CELL_IDS]: [0, 1],\n      [ROW_COUNT]: [0, 1],\n      [ROW_IDS]: [0, 1],\n      [SORTED_ROW_IDS]: [0, 5],\n      [ROW]: [1, 2],\n      [CELL_IDS]: [0, 2],\n      [CELL]: [1, 3],\n    },\n    ([hasAndForEach, argumentCount], gettable) => {\n      arrayForEach(\n        hasAndForEach ? [GET, 'has', 'forEach'] : [GET],\n        (prefix) =>\n          (queries[prefix + RESULT + gettable] = (...args) =>\n            resultStore[prefix + gettable](...args)),\n      );\n      queries[ADD + RESULT + gettable + LISTENER] = (...args) =>\n        resultStore[ADD + gettable + LISTENER](\n          ...slice(args, 0, argumentCount),\n          (_store, ...listenerArgs) =>\n            args[argumentCount](queries, ...listenerArgs),\n          true,\n        );\n    },\n  );\n  return objFreeze(queries);\n});\n\nconst createRelationships = getCreateFunction((store) => {\n  const remoteTableIds = mapNew();\n  const remoteRowIdListeners = mapNew();\n  const localRowIdsListeners = mapNew();\n  const linkedRowIdsListeners = mapNew();\n  const [addListener, callListeners, delListenerImpl] = getListenerFunctions(\n    () => relationships,\n  );\n  const [\n    getStore,\n    getRelationshipIds,\n    forEachRelationshipImpl,\n    hasRelationship,\n    getLocalTableId,\n    getRelationship,\n    ,\n    ,\n    setDefinitionAndListen,\n    delDefinition,\n    addRelationshipIdsListener,\n    destroy,\n  ] = getDefinableFunctions(\n    store,\n    () => [mapNew(), mapNew(), mapNew(), mapNew()],\n    (value) => (isUndefined(value) ? void 0 : value + EMPTY_STRING),\n    addListener,\n    callListeners,\n  );\n  const getLinkedRowIdsCache = (relationshipId, firstRowId, skipCache) =>\n    ifNotUndefined(\n      getRelationship(relationshipId),\n      ([remoteRows, , linkedRowsCache]) => {\n        if (!collHas(linkedRowsCache, firstRowId)) {\n          const linkedRows = setNew();\n          if (\n            getLocalTableId(relationshipId) != getRemoteTableId(relationshipId)\n          ) {\n            setAdd(linkedRows, firstRowId);\n          } else {\n            let rowId = firstRowId;\n            while (!isUndefined(rowId) && !collHas(linkedRows, rowId)) {\n              setAdd(linkedRows, rowId);\n              rowId = mapGet(remoteRows, rowId);\n            }\n          }\n          if (skipCache) {\n            return linkedRows;\n          }\n          mapSet(linkedRowsCache, firstRowId, linkedRows);\n        }\n        return mapGet(linkedRowsCache, firstRowId);\n      },\n    );\n  const delLinkedRowIdsCache = (relationshipId, firstRowId) =>\n    ifNotUndefined(getRelationship(relationshipId), ([, , linkedRowsCache]) =>\n      mapSet(linkedRowsCache, firstRowId),\n    );\n  const setRelationshipDefinition = (\n    relationshipId,\n    localTableId,\n    remoteTableId,\n    getRemoteRowId2,\n  ) => {\n    mapSet(remoteTableIds, relationshipId, remoteTableId);\n    setDefinitionAndListen(\n      relationshipId,\n      localTableId,\n      (change, changedRemoteRowIds) => {\n        const changedLocalRows = setNew();\n        const changedRemoteRows = setNew();\n        const changedLinkedRows = setNew();\n        const [localRows, remoteRows] = getRelationship(relationshipId);\n        collForEach(\n          changedRemoteRowIds,\n          ([oldRemoteRowId, newRemoteRowId], localRowId) => {\n            if (!isUndefined(oldRemoteRowId)) {\n              setAdd(changedRemoteRows, oldRemoteRowId);\n              ifNotUndefined(\n                mapGet(remoteRows, oldRemoteRowId),\n                (oldRemoteRow) => {\n                  collDel(oldRemoteRow, localRowId);\n                  if (collIsEmpty(oldRemoteRow)) {\n                    mapSet(remoteRows, oldRemoteRowId);\n                  }\n                },\n              );\n            }\n            if (!isUndefined(newRemoteRowId)) {\n              setAdd(changedRemoteRows, newRemoteRowId);\n              if (!collHas(remoteRows, newRemoteRowId)) {\n                mapSet(remoteRows, newRemoteRowId, setNew());\n              }\n              setAdd(mapGet(remoteRows, newRemoteRowId), localRowId);\n            }\n            setAdd(changedLocalRows, localRowId);\n            mapSet(localRows, localRowId, newRemoteRowId);\n            mapForEach(\n              mapGet(linkedRowIdsListeners, relationshipId),\n              (firstRowId) => {\n                if (\n                  collHas(\n                    getLinkedRowIdsCache(relationshipId, firstRowId),\n                    localRowId,\n                  )\n                ) {\n                  setAdd(changedLinkedRows, firstRowId);\n                }\n              },\n            );\n          },\n        );\n        change();\n        collForEach(changedLocalRows, (localRowId) =>\n          callListeners(remoteRowIdListeners, [relationshipId, localRowId]),\n        );\n        collForEach(changedRemoteRows, (remoteRowId) =>\n          callListeners(localRowIdsListeners, [relationshipId, remoteRowId]),\n        );\n        collForEach(changedLinkedRows, (firstRowId) => {\n          delLinkedRowIdsCache(relationshipId, firstRowId);\n          callListeners(linkedRowIdsListeners, [relationshipId, firstRowId]);\n        });\n      },\n      getRowCellFunction(getRemoteRowId2),\n    );\n    return relationships;\n  };\n  const forEachRelationship = (relationshipCallback) =>\n    forEachRelationshipImpl((relationshipId) =>\n      relationshipCallback(relationshipId, (rowCallback) =>\n        store.forEachRow(getLocalTableId(relationshipId), rowCallback),\n      ),\n    );\n  const delRelationshipDefinition = (relationshipId) => {\n    mapSet(remoteTableIds, relationshipId);\n    delDefinition(relationshipId);\n    return relationships;\n  };\n  const getRemoteTableId = (relationshipId) =>\n    mapGet(remoteTableIds, relationshipId);\n  const getRemoteRowId = (relationshipId, localRowId) =>\n    mapGet(getRelationship(relationshipId)?.[0], localRowId);\n  const getLocalRowIds = (relationshipId, remoteRowId) =>\n    collValues(mapGet(getRelationship(relationshipId)?.[1], remoteRowId));\n  const getLinkedRowIds = (relationshipId, firstRowId) =>\n    isUndefined(getRelationship(relationshipId))\n      ? [firstRowId]\n      : collValues(getLinkedRowIdsCache(relationshipId, firstRowId, true));\n  const addRemoteRowIdListener = (relationshipId, localRowId, listener) =>\n    addListener(listener, remoteRowIdListeners, [relationshipId, localRowId]);\n  const addLocalRowIdsListener = (relationshipId, remoteRowId, listener) =>\n    addListener(listener, localRowIdsListeners, [relationshipId, remoteRowId]);\n  const addLinkedRowIdsListener = (relationshipId, firstRowId, listener) => {\n    getLinkedRowIdsCache(relationshipId, firstRowId);\n    return addListener(listener, linkedRowIdsListeners, [\n      relationshipId,\n      firstRowId,\n    ]);\n  };\n  const delListener = (listenerId) => {\n    delLinkedRowIdsCache(...(delListenerImpl(listenerId) ?? []));\n    return relationships;\n  };\n  const getListenerStats = () => ({\n    remoteRowId: collSize3(remoteRowIdListeners),\n    localRowIds: collSize3(localRowIdsListeners),\n    linkedRowIds: collSize3(linkedRowIdsListeners),\n  });\n  const relationships = {\n    setRelationshipDefinition,\n    delRelationshipDefinition,\n    getStore,\n    getRelationshipIds,\n    forEachRelationship,\n    hasRelationship,\n    getLocalTableId,\n    getRemoteTableId,\n    getRemoteRowId,\n    getLocalRowIds,\n    getLinkedRowIds,\n    addRelationshipIdsListener,\n    addRemoteRowIdListener,\n    addLocalRowIdsListener,\n    addLinkedRowIdsListener,\n    delListener,\n    destroy,\n    getListenerStats,\n  };\n  return objFreeze(relationships);\n});\n\nexport {\n  addOrRemoveHash,\n  createCheckpoints,\n  createIndexes,\n  createMergeableStore,\n  createMetrics,\n  createQueries,\n  createRelationships,\n  createStore,\n  defaultSorter,\n  getCellHash,\n  getCellInRowHash,\n  getHash,\n  getHlcFunctions,\n  getRowHash,\n  getRowInTableHash,\n  getTableHash,\n  getTableInTablesHash,\n  getTablesHash,\n  getUniqueId,\n  getValueHash,\n  getValueInValuesHash,\n  getValuesHash,\n};\n"]}