tinybase 5.0.0-beta.2 → 5.0.0-beta.21

package/lib/debug/tools.js

@@ -1,3299 +0,0 @@
-const getTypeOf = (thing) => typeof thing;
-const TINYBASE = 'tinybase';
-const EMPTY_STRING = '';
-const COMMA = ',';
-const STRING = getTypeOf(EMPTY_STRING);
-const BOOLEAN = getTypeOf(true);
-const NUMBER = getTypeOf(0);
-const TYPE = 'type';
-const DEFAULT = 'default';
-const LISTENER = 'Listener';
-const GET = 'get';
-const ADD = 'add';
-const HAS = 'Has';
-const IDS = 'Ids';
-const TABLE = 'Table';
-const TABLES = TABLE + 's';
-const TABLE_IDS = TABLE + IDS;
-const ROW = 'Row';
-const ROW_IDS = ROW + IDS;
-const SORTED_ROW_IDS = 'Sorted' + ROW + IDS;
-const CELL = 'Cell';
-const CELL_IDS = CELL + IDS;
-const VALUE = 'Value';
-const VALUES = VALUE + 's';
-const VALUE_IDS = VALUE + IDS;
-
-const promise = Promise;
-const isFiniteNumber = isFinite;
-const isUndefined = (thing) => thing == void 0;
-const ifNotUndefined = (value, then, otherwise) =>
-  isUndefined(value) ? otherwise?.() : then(value);
-const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
-const isString = (thing) => getTypeOf(thing) == STRING;
-const isArray = (thing) => Array.isArray(thing);
-const slice = (arrayOrString, start, end) => arrayOrString.slice(start, end);
-const size = (arrayOrString) => arrayOrString.length;
-const promiseAll = async (promises) => promise.all(promises);
-
-const getCellOrValueType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
-    ? type
-    : void 0;
-};
-
-const arrayEvery = (array, cb) => array.every(cb);
-const arraySort = (array, sorter) => array.sort(sorter);
-const arrayForEach = (array, cb) => array.forEach(cb);
-const arrayJoin = (array, sep = EMPTY_STRING) => array.join(sep);
-const arrayMap = (array, cb) => array.map(cb);
-const arrayFilter = (array, cb) => array.filter(cb);
-const arrayPush = (array, ...values) => array.push(...values);
-const arrayPop = (array) => array.pop();
-const arrayUnshift = (array, ...values) => array.unshift(...values);
-const arrayShift = (array) => array.shift();
-
-const object = Object;
-const getPrototypeOf = (obj) => object.getPrototypeOf(obj);
-const objEntries = object.entries;
-const objIds = object.keys;
-const objFreeze = object.freeze;
-const isObject = (obj) =>
-  !isUndefined(obj) &&
-  ifNotUndefined(
-    getPrototypeOf(obj),
-    (objPrototype) =>
-      objPrototype == object.prototype ||
-      isUndefined(getPrototypeOf(objPrototype)),
-    /* istanbul ignore next */
-    () => true,
-  );
-const objToArray = (obj, cb) =>
-  arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
-const objSize = (obj) => size(objIds(obj));
-const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
-
-const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
-const collValues = (coll) => [...(coll?.values() ?? [])];
-const collForEach = (coll, cb) => coll?.forEach(cb);
-const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
-
-const mapNew = (entries) => new Map(entries);
-const mapGet = (map, key) => map?.get(key);
-const mapForEach = (map, cb) =>
-  collForEach(map, (value, key) => cb(key, value));
-const mapMap = (coll, cb) =>
-  arrayMap([...(coll?.entries() ?? [])], ([key, value]) => cb(value, key));
-const mapSet = (map, key, value) =>
-  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
-const mapEnsure = (map, key, getDefaultValue) => {
-  if (!collHas(map, key)) {
-    mapSet(map, key, getDefaultValue());
-  }
-  return mapGet(map, key);
-};
-
-const upper = (str) => str.toUpperCase();
-const lower = (str) => str.toLowerCase();
-const A = 'a ';
-const A_FUNCTION_FOR = 'A function for';
-const AND_REGISTERS =
-  ', and registers a listener so that any changes to that result will cause a re-render';
-const CALLBACK = 'Callback';
-const COUNT = 'Count';
-const DEL = 'Del';
-const DEPS = 'Deps';
-const DEPS_SUFFIX = DEPS + '?: React.DependencyList';
-const DO_ROLLBACK_PARAM = 'doRollback?: DoRollback';
-const DO_ACTIONS_AND_ROLLBACK_PARAMS =
-  'actions: () => Return, ' + DO_ROLLBACK_PARAM;
-const EXPORT = 'export';
-const ID = 'Id';
-const INVALID = 'Invalid';
-const JSON$1 = 'Json';
-const LISTENER_ = lower(LISTENER);
-const OPTIONAL_COLON = '?: ';
-const OR_UNDEFINED = ' | undefined';
-const NON_NULLABLE = 'NonNullable';
-const PARTIAL = 'Partial';
-const PROPS = 'Props';
-const PROVIDER = 'Provider';
-const REGISTERS_A_LISTENER = `Registers a ${LISTENER_} that will be called`;
-const REPRESENTS = 'Represents';
-const ROW_ID_PARAM = 'rowId: ' + ID;
-const SCHEMA = 'Schema';
-const SET = 'Set';
-const SORTED_ARGS = ', descending?: boolean, offset?: number, limit?: number';
-const SQUARE_BRACKETS = '[]';
-const THE_STORE = 'the Store';
-const TRANSACTION = 'Transaction';
-const TRANSACTION_CHANGES = TRANSACTION + 'Changes';
-const TRANSACTION_ = lower(TRANSACTION);
-const TRANSACTION_DOC =
-  'Execute a ' + TRANSACTION_ + ' to make multiple mutations';
-const START_TRANSACTION_DOC = 'Explicitly starts a ' + TRANSACTION_;
-const FINISH_TRANSACTION_DOC = 'Explicitly finishes a ' + TRANSACTION_;
-const THE_END_OF_THE_TRANSACTION = 'the end of the ' + TRANSACTION_;
-const VOID = 'void';
-const RETURNS_VOID = ' => ' + VOID;
-const WHEN_SET = 'WhenSet';
-const WHEN_SETTING_IT = ' when setting it';
-const A_STRING_SERIALIZATION_OF = A + 'string serialization of';
-const SPACE = ' ';
-const GETS_A_CALLBACK_THAT_CAN = 'Gets a callback that can ';
-const THE = 'the ';
-const THE_SCHEMA_FOR = ' the schema for';
-const getHasDoc = (has = 0) => (has ? 'the existence of ' : '');
-const getTheContentOfDoc = (content = 0, theStore = 0, has = 0) =>
-  getHasDoc(has) +
-  `the ${CONTENT[content]}content of` +
-  (theStore ? SPACE + THE_STORE : EMPTY_STRING);
-const getTheContentOfTheStoreDoc = (content = 0, verb, set = 0, has = 0) =>
-  VERBS[verb] +
-  SPACE +
-  getHasDoc(has) +
-  getTheContentOfDoc(content, 1) +
-  (set ? ' when setting it' : EMPTY_STRING);
-const getRowTypeDoc = (tableId, set = 0) =>
-  REPRESENTS +
-  ` a Row when ${set ? 's' : 'g'}etting ${getTheContentOfDoc()} the '${tableId}' ` +
-  TABLE;
-const getIdsDoc = (idsNoun, parentNoun, sorted = 0) =>
-  `Gets ${sorted ? 'sorted, paginated' : 'the'} Ids of the ${idsNoun}s in ` +
-  parentNoun;
-const getForEachDoc = (childNoun, parentNoun) =>
-  `Calls a function for each ${childNoun} in ` + parentNoun;
-const getPropsDoc = (childNoun) =>
-  'The props passed to a component that renders ' + childNoun;
-const getCallbackDoc = (takes) => 'A function that takes ' + takes;
-const getListenerTypeDoc = (childNoun, parentNoun = 0, has = 0) =>
-  A_FUNCTION_FOR +
-  ' listening to changes to ' +
-  getHasDoc(has) +
-  NOUNS[childNoun] +
-  ' in ' +
-  NOUNS[parentNoun];
-const getListenerDoc = (childNoun, parentNoun, pluralChild = 0, has = 0) =>
-  REGISTERS_A_LISTENER +
-  ' whenever ' +
-  getHasDoc(has) +
-  NOUNS[childNoun] +
-  ' in ' +
-  NOUNS[parentNoun] +
-  ' change' +
-  (pluralChild ? EMPTY_STRING : 's');
-const getTableDoc = (tableId) => `the '${tableId}' ` + TABLE;
-const getRowDoc = (tableId) => 'the specified Row in ' + getTableDoc(tableId);
-const getTableContentDoc = (tableId, verb = 0, has = 0) =>
-  VERBS[verb] +
-  SPACE +
-  getTheContentOfDoc(0, 0, has) +
-  SPACE +
-  getTableDoc(tableId);
-const getRowContentDoc = (tableId, verb = 0, has = 0) =>
-  VERBS[verb] + ` ${getTheContentOfDoc(0, 0, has)} ` + getRowDoc(tableId);
-const getCellContentDoc = (tableId, cellId, verb = 0, has = 0) =>
-  VERBS[verb] +
-  SPACE +
-  getHasDoc(has) +
-  `the '${cellId}' Cell for ` +
-  getRowDoc(tableId);
-const getValueContentDoc = (valueId, verb = 0, has = 0) =>
-  VERBS[verb] + SPACE + getHasDoc(has) + `the '${valueId}' Value`;
-const VERBS = [
-  'Gets',
-  'Checks existence of',
-  'Sets',
-  'Deletes',
-  'Sets part of',
-  REPRESENTS,
-  'Gets ' + A_STRING_SERIALIZATION_OF,
-  'Sets ' + A_STRING_SERIALIZATION_OF,
-  REGISTERS_A_LISTENER + ' whenever',
-  GETS_A_CALLBACK_THAT_CAN + 'set',
-  GETS_A_CALLBACK_THAT_CAN + 'add',
-  GETS_A_CALLBACK_THAT_CAN + 'set part of',
-  GETS_A_CALLBACK_THAT_CAN + 'delete',
-  'Renders',
-  'Gets ' + A_STRING_SERIALIZATION_OF + THE_SCHEMA_FOR,
-  'Sets' + THE_SCHEMA_FOR,
-  'Deletes' + THE_SCHEMA_FOR,
-];
-const METHOD_PREFIX_VERBS = [
-  GET,
-  'has',
-  'set',
-  'del',
-  'set',
-  // partial
-  'forEach',
-  ADD,
-  EMPTY_STRING,
-];
-const NOUNS = [
-  THE_STORE,
-  TABLES,
-  THE + TABLE + SPACE + IDS,
-  A + TABLE,
-  THE + ROW + SPACE + IDS,
-  A + ROW,
-  THE + CELL + SPACE + IDS,
-  A + CELL,
-  'invalid Cell changes',
-  VALUES,
-  THE + VALUE + SPACE + IDS,
-  A + VALUE,
-  'invalid Value changes',
-  THE + 'sorted ' + ROW + SPACE + IDS,
-  THE + CELL + SPACE + IDS + ' anywhere',
-  THE + 'number of Rows',
-  A + CELL + ' anywhere',
-];
-const CONTENT = [EMPTY_STRING, 'tabular ', 'keyed value '];
-
-const setNew = (entryOrEntries) =>
-  new Set(
-    isArray(entryOrEntries) || isUndefined(entryOrEntries)
-      ? entryOrEntries
-      : [entryOrEntries],
-  );
-const setAdd = (set, value) => set?.add(value);
-
-const NON_ALPHA = /[^A-Za-z]+/;
-const NON_ALPHANUMERIC = /[^A-Za-z0-9]+/;
-const JSDOC = /^( *)\/\*\* *(.*?) *\*\/$/gm;
-const stringHasComma = (str) => str.includes(COMMA);
-const mapUnique = (map, id, value, index = 1) => {
-  const uniqueId = `${id}${index == 1 ? '' : index}`;
-  if (collHas(map, uniqueId)) {
-    return mapUnique(map, id, value, index + 1);
-  } else {
-    mapSet(map, uniqueId, value);
-    return uniqueId;
-  }
-};
-const formatJsDoc = (file) =>
-  file.replace(JSDOC, (_, indent, text) => {
-    const lineLength = 77 - size(indent);
-    return `${indent}/**
-${text.replace(
-  new RegExp(`([^\\n]{1,${lineLength}})(\\s|$)`, 'g'),
-  `${indent} * $1
-`,
-)}${indent} */`;
-  });
-const flat = (array) => array.flat(1e3);
-const camel = (str, firstCap = 0) =>
-  arrayJoin(
-    arrayMap(
-      str.split(NON_ALPHANUMERIC),
-      (word, w) =>
-        (w > 0 || firstCap ? upper : lower)(slice(word, 0, 1)) + slice(word, 1),
-    ),
-  );
-const snake = (str) =>
-  upper(
-    arrayJoin(
-      (str && !NON_ALPHA.test(str[0]) ? str : ' ' + str).split(
-        NON_ALPHANUMERIC,
-      ),
-      '_',
-    ),
-  );
-const comment = (doc) => `/** ${doc}. */`;
-const getParameterList = (...params) =>
-  arrayJoin(
-    arrayFilter(params, (param) => param),
-    ', ',
-  );
-const getFieldTypeList = (...props) => '{' + arrayJoin(props, '; ') + '}';
-const getPropTypeList = (...props) =>
-  getFieldTypeList(...arrayMap(props, (prop) => 'readonly ' + prop));
-const getCodeFunctions = () => {
-  const allImports = [mapNew(), mapNew(), mapNew(), mapNew()];
-  const types = mapNew();
-  const constants = mapNew();
-  const build = (...lines) => arrayJoin(flat(lines), '\n');
-  const addImport = (location, source, ...items) =>
-    arrayForEach(items, (item) =>
-      arrayForEach([0, 1], (eachLocation) =>
-        (location ?? eachLocation) == eachLocation
-          ? setAdd(mapEnsure(allImports[eachLocation], source, setNew), item)
-          : 0,
-      ),
-    );
-  const addType = (name, body, doc, generic = EMPTY_STRING, exported = 1) =>
-    mapUnique(types, name, [body, doc, generic, exported]);
-  const addInternalFunction = (name, parameters, body) =>
-    mapUnique(
-      constants,
-      name,
-      isArray(body)
-        ? [`(${parameters}) => {`, body, '}']
-        : [`(${parameters}) => ${body}`],
-    );
-  const addConstant = (name, body) =>
-    mapGet(constants, name) === body ? name : mapUnique(constants, name, body);
-  const getSortableImport = (importMaybeAs) => {
-    const as = importMaybeAs.indexOf(' as ');
-    return as != -1 ? slice(importMaybeAs, as + 4) : importMaybeAs;
-  };
-  const getImports = (location = 0) =>
-    arrayMap(
-      [
-        ...arraySort(
-          mapMap(
-            allImports[location],
-            (items, source) =>
-              `import {${arrayJoin(
-                arraySort(collValues(items), (import1, import2) =>
-                  getSortableImport(import1) > getSortableImport(import2)
-                    ? 1
-                    : -1,
-                ),
-                ', ',
-              )}} from '${source}';`,
-          ),
-          (import1, import2) =>
-            stringHasComma(import1) != stringHasComma(import2)
-              ? stringHasComma(import1)
-                ? -1
-                : 1
-              : import1 > import2
-                ? 1
-                : -1,
-        ),
-        EMPTY_STRING,
-      ],
-      (line) => line.replace('{React}', 'React'),
-      // sigh
-    );
-  const getTypes = () =>
-    mapMap(types, ([body, doc, generic, exported], name) => [
-      comment(doc),
-      `${exported ? EXPORT + ' ' : EMPTY_STRING}type ${name}${generic} = ${body};`,
-      EMPTY_STRING,
-    ]);
-  const getConstants = () =>
-    mapMap(constants, (body, name) => {
-      body = isArray(body) ? body : [body];
-      arrayPush(body, `${arrayPop(body)};`);
-      return [`const ${name} = ${arrayShift(body)}`, body, EMPTY_STRING];
-    });
-  return [
-    build,
-    addImport,
-    addType,
-    addInternalFunction,
-    addConstant,
-    getImports,
-    getTypes,
-    getConstants,
-  ];
-};
-
-const getCreateFunction = (getFunction, initFunction) => {
-  const thingsByStore = /* @__PURE__ */ new WeakMap();
-  return (store) => {
-    if (!thingsByStore.has(store)) {
-      thingsByStore.set(store, getFunction(store));
-    }
-    const thing = thingsByStore.get(store);
-    initFunction?.(thing);
-    return thing;
-  };
-};
-
-const getSchemaFunctions = (tablesSchema, valuesSchema, addConstant) => {
-  const mapTablesSchema = (callback) =>
-    objToArray(tablesSchema, (_, tableId) => {
-      return callback(
-        tableId,
-        camel(tableId, 1),
-        addConstant(snake(tableId), `'${tableId}'`),
-      );
-    });
-  const mapCellSchema = (tableId, callback) =>
-    objToArray(tablesSchema[tableId], (cellSchema, cellId) =>
-      callback(
-        cellId,
-        cellSchema[TYPE],
-        cellSchema[DEFAULT],
-        addConstant(snake(cellId), `'${cellId}'`),
-        camel(cellId, 1),
-      ),
-    );
-  const mapValuesSchema = (callback) =>
-    objToArray(valuesSchema, (valueSchema, valueId) =>
-      callback(
-        valueId,
-        valueSchema[TYPE],
-        valueSchema[DEFAULT],
-        addConstant(snake(valueId), `'${valueId}'`),
-        camel(valueId, 1),
-      ),
-    );
-  return [mapTablesSchema, mapCellSchema, mapValuesSchema];
-};
-
-const getTypeFunctions = (
-  addType,
-  mapTablesSchema,
-  mapCellSchema,
-  mapValuesSchema,
-) => {
-  const getTablesTypes = (storeInstance, storeType) => {
-    const storeParam = storeInstance + ': ' + storeType;
-    const tablesType = addType(
-      TABLES,
-      getFieldTypeList(
-        ...mapTablesSchema(
-          (tableId) =>
-            `'${tableId}'?: {[rowId: Id]: ` +
-            getFieldTypeList(
-              ...mapCellSchema(
-                tableId,
-                (cellId, type, defaultValue) =>
-                  `'${cellId}'${isUndefined(defaultValue) ? '?' : EMPTY_STRING}: ${type}`,
-              ),
-            ) +
-            '}',
-        ),
-      ),
-      getTheContentOfTheStoreDoc(1, 5),
-    );
-    const tablesWhenSetType = addType(
-      TABLES + WHEN_SET,
-      getFieldTypeList(
-        ...mapTablesSchema(
-          (tableId) =>
-            `'${tableId}'?: {[rowId: Id]: ` +
-            getFieldTypeList(
-              ...mapCellSchema(
-                tableId,
-                (cellId, type) => `'${cellId}'?: ${type}`,
-              ),
-            ) +
-            '}',
-        ),
-      ),
-      getTheContentOfTheStoreDoc(1, 5, 1),
-    );
-    const tableIdType = addType(
-      TABLE + ID,
-      'keyof ' + tablesType,
-      'A ' + TABLE + ' Id in ' + THE_STORE,
-    );
-    const tIdGeneric = `<TId extends ${tableIdType}>`;
-    const tableType = addType(
-      TABLE,
-      NON_NULLABLE + `<${tablesType}[TId]>`,
-      'A ' + TABLE + ' in ' + THE_STORE,
-      tIdGeneric,
-    );
-    const tableWhenSetType = addType(
-      TABLE + WHEN_SET,
-      NON_NULLABLE + `<${tablesWhenSetType}[TId]>`,
-      'A ' + TABLE + ' in ' + THE_STORE + WHEN_SETTING_IT,
-      tIdGeneric,
-    );
-    const rowType = addType(
-      ROW,
-      tableType + '<TId>[Id]',
-      'A ' + ROW + ' in a ' + TABLE,
-      tIdGeneric,
-    );
-    const rowWhenSetType = addType(
-      ROW + WHEN_SET,
-      tableWhenSetType + '<TId>[Id]',
-      'A ' + ROW + ' in a ' + TABLE + WHEN_SETTING_IT,
-      tIdGeneric,
-    );
-    const cellIdType = addType(
-      CELL + ID,
-      `Extract<keyof ${rowType}<TId>, Id>`,
-      'A ' + CELL + ' Id in a ' + ROW,
-      tIdGeneric,
-    );
-    const cellType = addType(
-      CELL,
-      NON_NULLABLE + `<${tablesType}[TId]>[Id][CId]`,
-      'A ' + CELL + ' in a ' + ROW,
-      `<TId extends ${tableIdType}, CId extends ${cellIdType}<TId>>`,
-    );
-    const cellIdCellArrayType = addType(
-      'CellIdCellArray',
-      `CId extends ${cellIdType}<TId> ? [cellId: CId, cell: ${cellType}<TId, CId>] : never`,
-      CELL + ' Ids and types in a ' + ROW,
-      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
-      0,
-    );
-    const cellCallbackType = addType(
-      CELL + CALLBACK,
-      `(...[cellId, cell]: ${cellIdCellArrayType}<TId>)` + RETURNS_VOID,
-      getCallbackDoc(A + CELL + ' Id, and ' + CELL),
-      tIdGeneric,
-    );
-    const rowCallbackType = addType(
-      ROW + CALLBACK,
-      '(rowId: Id, forEachCell: (cellCallback: CellCallback<TId>) ' +
-        RETURNS_VOID +
-        ') ' +
-        RETURNS_VOID,
-      getCallbackDoc(A + ROW + ' Id, and a ' + CELL + ' iterator'),
-      tIdGeneric,
-    );
-    const tableCellCallbackType = addType(
-      TABLE + CELL + CALLBACK,
-      `(cellId: ${cellIdType}<TId>, count: number) ` + RETURNS_VOID,
-      getCallbackDoc(A + CELL + ' Id, and count of how many times it appears'),
-      tIdGeneric,
-    );
-    const tableIdForEachRowArrayType = addType(
-      'TableIdForEachRowArray',
-      `TId extends ${tableIdType} ? [tableId: TId, forEachRow: (rowCallback: ${rowCallbackType}<TId>)${RETURNS_VOID}] : never`,
-      TABLE + ' Ids and callback types',
-      `<TId = ${tableIdType}>`,
-      0,
-    );
-    const tableCallbackType = addType(
-      TABLE + CALLBACK,
-      `(...[tableId, forEachRow]: ${tableIdForEachRowArrayType})` +
-        RETURNS_VOID,
-      getCallbackDoc(A + TABLE + ' Id, and a ' + ROW + ' iterator'),
-      EMPTY_STRING,
-    );
-    const tableIdRowIdCellIdArrayType = addType(
-      'TableIdRowIdCellIdArray',
-      `TId extends ${tableIdType} ? [tableId: TId, rowId: Id, cellId: ${cellIdType}<TId>] : never`,
-      'Ids for GetCellChange',
-      `<TId = ${tableIdType}>`,
-      0,
-    );
-    const getCellChangeType = addType(
-      'GetCellChange',
-      `(...[tableId, rowId, cellId]: ${tableIdRowIdCellIdArrayType}) => CellChange`,
-      A_FUNCTION_FOR +
-        ` returning information about any Cell's changes during a ` +
-        TRANSACTION_,
-    );
-    const hasTablesListenerType = addType(
-      HAS + TABLES + LISTENER,
-      `(${storeParam}, hasTables: boolean)` + RETURNS_VOID,
-      getListenerTypeDoc(1, 0, 1),
-    );
-    const tablesListenerType = addType(
-      TABLES + LISTENER,
-      `(${storeParam}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(1),
-    );
-    const tableIdsListenerType = addType(
-      TABLE_IDS + LISTENER,
-      `(${storeParam})` + RETURNS_VOID,
-      getListenerTypeDoc(2),
-    );
-    const hasTableListenerType = addType(
-      HAS + TABLE + LISTENER,
-      `(${storeParam}, tableId: ${tableIdType}, hasTable: boolean)` +
-        RETURNS_VOID,
-      getListenerTypeDoc(3, 0, 1),
-    );
-    const tableListenerType = addType(
-      TABLE + LISTENER,
-      `(${storeParam}, tableId: ${tableIdType}, getCellChange: ${getCellChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(3),
-    );
-    const tableCellIdsListenerType = addType(
-      TABLE + CELL_IDS + LISTENER,
-      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
-      getListenerTypeDoc(14, 3),
-    );
-    const hasTableCellListenerArgsArrayInnerType = addType(
-      'HasTableCellListenerArgsArrayInner',
-      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, cellId: CId, hasTableCell: boolean] : never`,
-      'Cell args for HasTableCellListener',
-      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
-      0,
-    );
-    const hasTableCellListenerArgsArrayOuterType = addType(
-      'HasTableCellListenerArgsArrayOuter',
-      `TId extends ${tableIdType} ? ` +
-        hasTableCellListenerArgsArrayInnerType +
-        '<TId> : never',
-      'Table args for HasTableCellListener',
-      `<TId = ${tableIdType}>`,
-      0,
-    );
-    const hasTableCellListenerType = addType(
-      HAS + TABLE + CELL + LISTENER,
-      `(...[${storeInstance}, tableId, cellId, hasTableCell]: ` +
-        hasTableCellListenerArgsArrayOuterType +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(16, 3, 1),
-    );
-    const rowCountListenerType = addType(
-      ROW + 'Count' + LISTENER,
-      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
-      getListenerTypeDoc(15, 3),
-    );
-    const rowIdsListenerType = addType(
-      ROW_IDS + LISTENER,
-      `(${storeParam}, tableId: ${tableIdType})` + RETURNS_VOID,
-      getListenerTypeDoc(4, 3),
-    );
-    const sortedRowIdsListenerType = addType(
-      SORTED_ROW_IDS + LISTENER,
-      '(' +
-        getParameterList(
-          storeParam,
-          'tableId: ' + tableIdType,
-          'cellId: Id' + OR_UNDEFINED,
-          'descending: boolean',
-          'offset: number',
-          'limit: number' + OR_UNDEFINED,
-          'sortedRowIds: Ids',
-        ) +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(13, 3),
-    );
-    const hasRowListenerType = addType(
-      HAS + ROW + LISTENER,
-      '(' +
-        getParameterList(
-          `${storeParam}`,
-          'tableId: ' + tableIdType,
-          ROW_ID_PARAM,
-          `hasRow: boolean`,
-        ) +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(5, 3, 1),
-    );
-    const rowListenerType = addType(
-      ROW + LISTENER,
-      '(' +
-        getParameterList(
-          `${storeParam}`,
-          'tableId: ' + tableIdType,
-          ROW_ID_PARAM,
-          `getCellChange: ${getCellChangeType}${OR_UNDEFINED}`,
-        ) +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(5, 3),
-    );
-    const cellIdsListenerType = addType(
-      CELL_IDS + LISTENER,
-      '(' +
-        getParameterList(
-          `${storeParam}`,
-          'tableId: ' + tableIdType,
-          ROW_ID_PARAM,
-        ) +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(6, 5),
-    );
-    const hasCellListenerArgsArrayInnerType = addType(
-      'HasCellListenerArgsArrayInner',
-      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, ${ROW_ID_PARAM}, cellId: CId, hasCell: boolean] : never`,
-      'Cell args for HasCellListener',
-      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
-      0,
-    );
-    const hasCellListenerArgsArrayOuterType = addType(
-      'HasCellListenerArgsArrayOuter',
-      `TId extends ${tableIdType} ? ` +
-        hasCellListenerArgsArrayInnerType +
-        '<TId> : never',
-      'Table args for HasCellListener',
-      `<TId = ${tableIdType}>`,
-      0,
-    );
-    const hasCellListenerType = addType(
-      HAS + CELL + LISTENER,
-      `(...[${storeInstance}, tableId, rowId, cellId, hasCell]: ` +
-        hasCellListenerArgsArrayOuterType +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(7, 5, 1),
-    );
-    const cellListenerArgsArrayInnerType = addType(
-      'CellListenerArgsArrayInner',
-      `CId extends ${cellIdType}<TId> ? [${storeParam}, tableId: TId, ${ROW_ID_PARAM}, cellId: CId, newCell: ${cellType}<TId, CId> ${OR_UNDEFINED}, oldCell: ${cellType}<TId, CId> ${OR_UNDEFINED}, getCellChange: ${getCellChangeType} ${OR_UNDEFINED}] : never`,
-      'Cell args for CellListener',
-      `<TId extends ${tableIdType}, CId = ${cellIdType}<TId>>`,
-      0,
-    );
-    const cellListenerArgsArrayOuterType = addType(
-      'CellListenerArgsArrayOuter',
-      `TId extends ${tableIdType} ? ` +
-        cellListenerArgsArrayInnerType +
-        '<TId> : never',
-      'Table args for CellListener',
-      `<TId = ${tableIdType}>`,
-      0,
-    );
-    const cellListenerType = addType(
-      CELL + LISTENER,
-      `(...[${storeInstance}, tableId, rowId, cellId, newCell, oldCell, getCellChange]: ${cellListenerArgsArrayOuterType})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(7, 5),
-    );
-    const invalidCellListenerType = addType(
-      INVALID + CELL + LISTENER,
-      `(${storeParam}, tableId: Id, ${ROW_ID_PARAM}, cellId: Id, invalidCells: any[])` +
-        RETURNS_VOID,
-      getListenerTypeDoc(8),
-    );
-    return [
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      tableType,
-      tableWhenSetType,
-      rowType,
-      rowWhenSetType,
-      cellIdType,
-      cellType,
-      cellCallbackType,
-      rowCallbackType,
-      tableCellCallbackType,
-      tableCallbackType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      hasCellListenerType,
-      cellListenerType,
-      invalidCellListenerType,
-    ];
-  };
-  const getValuesTypes = (storeInstance, storeType) => {
-    const storeParam = storeInstance + ': ' + storeType;
-    const valuesType = addType(
-      VALUES,
-      getFieldTypeList(
-        ...mapValuesSchema(
-          (valueId, type, defaultValue) =>
-            `'${valueId}'${isUndefined(defaultValue) ? '?' : EMPTY_STRING}: ${type}`,
-        ),
-      ),
-      getTheContentOfTheStoreDoc(2, 5),
-    );
-    const valuesWhenSetType = addType(
-      VALUES + WHEN_SET,
-      getFieldTypeList(
-        ...mapValuesSchema((valueId, type) => `'${valueId}'?: ${type}`),
-      ),
-      getTheContentOfTheStoreDoc(2, 5, 1),
-    );
-    const valueIdType = addType(
-      VALUE + ID,
-      'keyof ' + valuesType,
-      'A ' + VALUE + ' Id in ' + THE_STORE,
-    );
-    const valueType = addType(
-      VALUE,
-      NON_NULLABLE + `<${valuesType}[VId]>`,
-      'A ' + VALUE + ' Id in ' + THE_STORE,
-      `<VId extends ${valueIdType}>`,
-    );
-    const valueIdValueArrayType = addType(
-      'ValueIdValueArray',
-      `VId extends ${valueIdType} ? [valueId: VId, value: ${valueType}<VId>] : never`,
-      VALUE + ' Ids and types in ' + THE_STORE,
-      `<VId = ${valueIdType}>`,
-      0,
-    );
-    const valueCallbackType = addType(
-      VALUE + CALLBACK,
-      `(...[valueId, value]: ${valueIdValueArrayType})` + RETURNS_VOID,
-      getCallbackDoc(A + VALUE + ' Id, and ' + VALUE),
-    );
-    const getValueChangeType = addType(
-      'GetValueChange',
-      `(valueId: ${valueIdType}) => ValueChange`,
-      A_FUNCTION_FOR +
-        ` returning information about any Value's changes during a ` +
-        TRANSACTION_,
-    );
-    const hasValuesListenerType = addType(
-      HAS + VALUES + LISTENER,
-      `(${storeParam}, hasValues: boolean)` + RETURNS_VOID,
-      getListenerTypeDoc(9, 0, 1),
-    );
-    const valuesListenerType = addType(
-      VALUES + LISTENER,
-      `(${storeParam}, getValueChange: ${getValueChangeType}${OR_UNDEFINED})` +
-        RETURNS_VOID,
-      getListenerTypeDoc(9),
-    );
-    const valueIdsListenerType = addType(
-      VALUE_IDS + LISTENER,
-      `(${storeParam})` + RETURNS_VOID,
-      getListenerTypeDoc(10),
-    );
-    const hasValueListenerType = addType(
-      HAS + VALUE + LISTENER,
-      `(${storeParam}, valueId: ValueId, hasValue: boolean)` + RETURNS_VOID,
-      getListenerTypeDoc(11, 0, 1),
-    );
-    const valueListenerArgsArrayType = addType(
-      'ValueListenerArgsArray',
-      `VId extends ${valueIdType} ? [${storeParam}, valueId: VId, newValue: ${valueType}<VId> ${OR_UNDEFINED}, oldValue: ${valueType}<VId> ${OR_UNDEFINED}, getValueChange: ${getValueChangeType} ${OR_UNDEFINED}] : never`,
-      'Value args for ValueListener',
-      `<VId = ${valueIdType}>`,
-      0,
-    );
-    const valueListenerType = addType(
-      VALUE + LISTENER,
-      `(...[${storeInstance}, valueId, newValue, oldValue, getValueChange]: ` +
-        valueListenerArgsArrayType +
-        ')' +
-        RETURNS_VOID,
-      getListenerTypeDoc(11),
-    );
-    const invalidValueListenerType = addType(
-      INVALID + VALUE + LISTENER,
-      `(${storeParam}, valueId: Id, invalidValues: any[])` + RETURNS_VOID,
-      getListenerTypeDoc(12),
-    );
-    return [
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      valueType,
-      valueCallbackType,
-      hasValuesListenerType,
-      valuesListenerType,
-      valueIdsListenerType,
-      hasValueListenerType,
-      valueListenerType,
-      invalidValueListenerType,
-    ];
-  };
-  const getTransactionListenerType = (storeInstance, storeType) =>
-    addType(
-      TRANSACTION + LISTENER,
-      `(${storeInstance}: ${storeType}, getTransactionChanges: GetTransactionChanges, getTransactionLog: GetTransactionLog)` +
-        RETURNS_VOID,
-      A_FUNCTION_FOR + ' listening to the completion of a ' + TRANSACTION_,
-    );
-  return [getTablesTypes, getValuesTypes, getTransactionListenerType];
-};
-
-const storeMethod = (method, parameters = EMPTY_STRING, cast = EMPTY_STRING) =>
-  `store.${method}(${parameters})` + (cast ? ' as ' + cast : EMPTY_STRING);
-const fluentStoreMethod = (method, parameters = EMPTY_STRING) =>
-  `fluent(() => ${storeMethod(method, parameters)})`;
-const storeListener = (
-  method,
-  beforeParameters = EMPTY_STRING,
-  afterParameters = EMPTY_STRING,
-) =>
-  `store.${method}(${beforeParameters ? beforeParameters + ', ' : EMPTY_STRING}proxy(listener)${afterParameters ? ', ' + afterParameters : EMPTY_STRING})`;
-const getStoreCoreApi = (tablesSchema, valuesSchema, module) => {
-  const [
-    build,
-    addImport,
-    addType,
-    addInternalFunction,
-    addConstant,
-    getImports,
-    getTypes,
-    getConstants,
-  ] = getCodeFunctions();
-  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
-    tablesSchema,
-    valuesSchema,
-    addConstant,
-  );
-  const [getTablesTypes, getValuesTypes, getTransactionListenerType] =
-    getTypeFunctions(addType, mapTablesSchema, mapCellSchema, mapValuesSchema);
-  const methods = mapNew();
-  const getMethods = (location = 0) =>
-    mapMap(methods, ([parameters, returnType, body, doc, generic], name) => {
-      const lines = location
-        ? [name + `: ${generic}(${parameters}): ${returnType} => ${body},`]
-        : [name + generic + `(${parameters}): ${returnType};`];
-      if (!location) {
-        arrayUnshift(lines, comment(doc));
-      }
-      arrayPush(lines, EMPTY_STRING);
-      return lines;
-    });
-  const addMethod = (
-    name,
-    parameters,
-    returnType,
-    body,
-    doc,
-    generic = EMPTY_STRING,
-  ) => mapUnique(methods, name, [parameters, returnType, body, doc, generic]);
-  const addProxyMethod = (
-    prefixVerb,
-    prefix,
-    underlyingName,
-    returnType,
-    doc,
-    params = EMPTY_STRING,
-    paramsInCall = EMPTY_STRING,
-    generic = EMPTY_STRING,
-  ) =>
-    addMethod(
-      METHOD_PREFIX_VERBS[prefixVerb] +
-        prefix +
-        (prefixVerb == 4 ? PARTIAL : EMPTY_STRING) +
-        underlyingName,
-      params,
-      returnType,
-      (returnType == storeType ? fluentStoreMethod : storeMethod)(
-        METHOD_PREFIX_VERBS[prefixVerb] +
-          (prefixVerb == 4 ? PARTIAL : EMPTY_STRING) +
-          underlyingName,
-        paramsInCall,
-        prefixVerb ? void 0 : returnType,
-      ),
-      doc,
-      generic,
-    );
-  const addProxyListener = (
-    underlyingName,
-    listenerType,
-    doc,
-    params = EMPTY_STRING,
-    paramsInCall = EMPTY_STRING,
-    mutator = 1,
-    generic = EMPTY_STRING,
-  ) =>
-    addMethod(
-      ADD + underlyingName + LISTENER,
-      (params ? params + ', ' : EMPTY_STRING) +
-        LISTENER_ +
-        ': ' +
-        listenerType +
-        (mutator ? ', mutator?: boolean' : EMPTY_STRING),
-      ID,
-      storeListener(
-        ADD + underlyingName + LISTENER,
-        paramsInCall,
-        mutator ? 'mutator' : EMPTY_STRING,
-      ),
-      doc,
-      generic,
-    );
-  const moduleDefinition = `./${camel(module)}.d`;
-  const storeType = camel(module, 1);
-  const storeInstance = camel(storeType);
-  const createSteps = [];
-  const mapCellOrValueTypes = mapNew();
-  let sharedTableTypes = [];
-  let sharedValueTypes = [];
-  addImport(
-    1,
-    moduleDefinition,
-    storeType,
-    `create${storeType} as create${storeType}Decl`,
-  );
-  if (!objIsEmpty(tablesSchema)) {
-    addImport(0, TINYBASE, 'CellChange');
-    addImport(null, TINYBASE, IDS);
-    const [
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      tableType,
-      tableWhenSetType,
-      rowType,
-      rowWhenSetType,
-      cellIdType,
-      _cellType,
-      cellCallbackType,
-      rowCallbackType,
-      tableCellCallbackType,
-      tableCallbackType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      hasCellListenerType,
-      cellListenerType,
-      invalidCellListenerType,
-    ] = getTablesTypes(storeInstance, storeType);
-    const tablesTypes = mapNew();
-    mapTablesSchema((tableId, tableName) => {
-      const tableIdGeneric = `<'${tableId}'>`;
-      const tableTypes = [
-        // Table
-        addType(
-          tableName + TABLE,
-          tableType + tableIdGeneric,
-          REPRESENTS + ` the '${tableId}' ` + TABLE,
-        ),
-        // TableWhenSet
-        addType(
-          tableName + TABLE + WHEN_SET,
-          tableWhenSetType + tableIdGeneric,
-          REPRESENTS + ` the '${tableId}' ` + TABLE + WHEN_SETTING_IT,
-        ),
-        // Row
-        addType(
-          tableName + ROW,
-          rowType + tableIdGeneric,
-          getRowTypeDoc(tableId),
-        ),
-        // RowWhenSet
-        addType(
-          tableName + ROW + WHEN_SET,
-          rowWhenSetType + tableIdGeneric,
-          getRowTypeDoc(tableId, 1),
-        ),
-        // CellId
-        addType(
-          tableName + CELL + ID,
-          cellIdType + tableIdGeneric,
-          `A Cell Id for the '${tableId}' ` + TABLE,
-        ),
-        // CellCallback
-        addType(
-          tableName + CELL + CALLBACK,
-          cellCallbackType + tableIdGeneric,
-          getCallbackDoc(
-            `a Cell Id and value from a Row in the '${tableId}' ` + TABLE,
-          ),
-        ),
-        // RowCallback
-        addType(
-          tableName + ROW + CALLBACK,
-          rowCallbackType + tableIdGeneric,
-          getCallbackDoc(
-            `a Row Id from the '${tableId}' Table, and a Cell iterator`,
-          ),
-        ),
-        // TableCellCallbackType
-        addType(
-          tableName + TABLE + CELL + CALLBACK,
-          tableCellCallbackType + tableIdGeneric,
-          getCallbackDoc(
-            `a Cell Id from anywhere in the '${tableId}' Table, and a count of how many times it appears`,
-          ),
-        ),
-      ];
-      mapSet(tablesTypes, tableId, tableTypes);
-      addImport(1, moduleDefinition, ...tableTypes);
-    });
-    addImport(
-      1,
-      moduleDefinition,
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      cellIdType,
-      tableCallbackType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      hasCellListenerType,
-      cellListenerType,
-      invalidCellListenerType,
-    );
-    sharedTableTypes = [
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      cellIdType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      hasCellListenerType,
-      cellListenerType,
-      tablesTypes,
-    ];
-    arrayForEach(
-      [
-        [tablesType],
-        [BOOLEAN],
-        [storeType, 'tables: ' + tablesWhenSetType, 'tables'],
-        [storeType],
-      ],
-      ([returnType, params, paramsInCall], verb) =>
-        addProxyMethod(
-          verb,
-          EMPTY_STRING,
-          TABLES,
-          returnType,
-          getTheContentOfTheStoreDoc(1, verb),
-          params,
-          paramsInCall,
-        ),
-    );
-    addProxyMethod(
-      0,
-      EMPTY_STRING,
-      TABLE_IDS,
-      tableIdType + SQUARE_BRACKETS,
-      getIdsDoc(TABLE, THE_STORE),
-    );
-    addProxyMethod(
-      5,
-      EMPTY_STRING,
-      TABLE,
-      VOID,
-      getForEachDoc(TABLE, THE_STORE),
-      'tableCallback: ' + tableCallbackType,
-      'tableCallback as any',
-    );
-    mapTablesSchema((tableId, tableName, TABLE_ID) => {
-      const [
-        tableType2,
-        tableWhenSetType2,
-        rowType2,
-        rowWhenSetType2,
-        cellIdType2,
-        cellCallbackType2,
-        rowCallbackType2,
-        tableCellCallbackType2,
-      ] = mapGet(tablesTypes, tableId);
-      arrayForEach(
-        [
-          [tableType2],
-          [BOOLEAN],
-          [storeType, 'table: ' + tableWhenSetType2, ', table'],
-          [storeType],
-        ],
-        ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
-          addProxyMethod(
-            verb,
-            tableName,
-            TABLE,
-            returnType,
-            getTableContentDoc(tableId, verb),
-            params,
-            TABLE_ID + paramsInCall,
-          ),
-      );
-      addProxyMethod(
-        0,
-        tableName,
-        TABLE + CELL_IDS,
-        IDS,
-        getIdsDoc(CELL, 'the whole of ' + getTableDoc(tableId)),
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyMethod(
-        5,
-        tableName,
-        TABLE + CELL,
-        VOID,
-        getForEachDoc(TABLE + CELL, 'the whole of ' + getTableDoc(tableId)),
-        'tableCellCallback: ' + tableCellCallbackType2,
-        TABLE_ID + ', tableCellCallback as any',
-      );
-      addProxyMethod(
-        0,
-        tableName,
-        ROW + COUNT,
-        'number',
-        'Gets the number of Rows in the ' + getTableDoc(tableId),
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyMethod(
-        0,
-        tableName,
-        ROW_IDS,
-        IDS,
-        getIdsDoc(ROW, getTableDoc(tableId)),
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyMethod(
-        0,
-        tableName,
-        SORTED_ROW_IDS,
-        IDS,
-        getIdsDoc(ROW, getTableDoc(tableId), 1),
-        'cellId?: ' + cellIdType2 + SORTED_ARGS,
-        TABLE_ID + ', cellId, descending, offset, limit',
-      );
-      addProxyMethod(
-        5,
-        tableName,
-        ROW,
-        VOID,
-        getForEachDoc(ROW, getTableDoc(tableId)),
-        'rowCallback: ' + rowCallbackType2,
-        TABLE_ID + ', rowCallback as any',
-      );
-      arrayForEach(
-        [
-          [rowType2],
-          [BOOLEAN],
-          [storeType, ', row: ' + rowWhenSetType2, ', row'],
-          [storeType],
-          [storeType, ', partialRow: ' + rowWhenSetType2, ', partialRow'],
-        ],
-        (
-          [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
-          verb,
-        ) =>
-          addProxyMethod(
-            verb,
-            tableName,
-            ROW,
-            returnType,
-            getRowContentDoc(tableId, verb),
-            ROW_ID_PARAM + params,
-            TABLE_ID + ', rowId' + paramsInCall,
-          ),
-      );
-      addProxyMethod(
-        6,
-        tableName,
-        ROW,
-        ID + OR_UNDEFINED,
-        'Add a new Row to ' + getTableDoc(tableId),
-        'row: ' + rowWhenSetType2 + ', reuseIds?: boolean',
-        TABLE_ID + ', row, reuseIds',
-      );
-      addProxyMethod(
-        0,
-        tableName,
-        CELL_IDS,
-        cellIdType2 + SQUARE_BRACKETS,
-        getIdsDoc(CELL, getRowDoc(tableId)),
-        ROW_ID_PARAM,
-        TABLE_ID + ', rowId',
-      );
-      addProxyMethod(
-        5,
-        tableName,
-        CELL,
-        VOID,
-        getForEachDoc(CELL, getRowDoc(tableId)),
-        ROW_ID_PARAM + ', cellCallback: ' + cellCallbackType2,
-        TABLE_ID + ', rowId, cellCallback as any',
-      );
-      mapCellSchema(
-        tableId,
-        (cellId, type, defaultValue, CELL_ID, cellName) => {
-          const mapCellType = 'Map' + camel(type, 1);
-          mapSet(mapCellOrValueTypes, type, mapCellType);
-          const returnCellType =
-            type + (isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING);
-          arrayForEach(
-            [
-              [returnCellType],
-              [BOOLEAN],
-              [storeType, `, cell: ${type} | ` + mapCellType, ', cell as any'],
-              [storeType],
-            ],
-            (
-              [returnType, params = EMPTY_STRING, paramsInCall = EMPTY_STRING],
-              verb,
-            ) =>
-              addProxyMethod(
-                verb,
-                tableName + cellName,
-                CELL,
-                returnType,
-                getCellContentDoc(tableId, cellId, verb),
-                ROW_ID_PARAM + params,
-                TABLE_ID + ', rowId, ' + CELL_ID + paramsInCall,
-              ),
-          );
-          addProxyMethod(
-            1,
-            tableName + cellName,
-            TABLE + CELL,
-            BOOLEAN,
-            VERBS[1] +
-              ` the '${cellId}' Cell anywhere in ` +
-              getTableDoc(tableId),
-            EMPTY_STRING,
-            TABLE_ID + ', ' + CELL_ID,
-          );
-        },
-      );
-    });
-    addProxyMethod(
-      0,
-      EMPTY_STRING,
-      TABLES + JSON$1,
-      JSON$1,
-      getTheContentOfTheStoreDoc(1, 6),
-    );
-    addProxyMethod(
-      2,
-      EMPTY_STRING,
-      TABLES + JSON$1,
-      storeType,
-      getTheContentOfTheStoreDoc(1, 7),
-      'tablesJson: ' + JSON$1,
-      'tables' + JSON$1,
-    );
-    addProxyListener(
-      HAS + TABLES,
-      hasTablesListenerType,
-      getTheContentOfTheStoreDoc(1, 8, 0, 1) + ' changes',
-    );
-    addProxyListener(
-      TABLES,
-      tablesListenerType,
-      getTheContentOfTheStoreDoc(1, 8) + ' changes',
-    );
-    addProxyListener(TABLE_IDS, tableIdsListenerType, getListenerDoc(2, 0, 1));
-    addProxyListener(
-      HAS + TABLE,
-      hasTableListenerType,
-      getListenerDoc(3, 0, 0, 1),
-      `tableId: ${tableIdType} | null`,
-      'tableId',
-    );
-    addProxyListener(
-      TABLE,
-      tableListenerType,
-      getListenerDoc(3, 0),
-      `tableId: ${tableIdType} | null`,
-      'tableId',
-    );
-    addProxyListener(
-      TABLE + CELL_IDS,
-      tableCellIdsListenerType,
-      getListenerDoc(14, 3, 1),
-      `tableId: ${tableIdType} | null`,
-      'tableId',
-    );
-    addProxyListener(
-      HAS + TABLE + CELL,
-      hasTableCellListenerType,
-      getListenerDoc(16, 3, 0, 1),
-      `tableId: ${tableIdType} | null, cellId: ${arrayJoin(
-        mapTablesSchema(
-          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
-        ),
-        ' | ',
-      )} | null`,
-      'tableId,  cellId',
-    );
-    addProxyListener(
-      ROW + COUNT,
-      rowCountListenerType,
-      getListenerDoc(15, 3),
-      `tableId: ${tableIdType} | null`,
-      'tableId',
-    );
-    addProxyListener(
-      ROW_IDS,
-      rowIdsListenerType,
-      getListenerDoc(4, 3, 1),
-      `tableId: ${tableIdType} | null`,
-      'tableId',
-    );
-    addProxyListener(
-      SORTED_ROW_IDS,
-      sortedRowIdsListenerType,
-      getListenerDoc(13, 3, 1),
-      getParameterList(
-        'tableId: TId',
-        `cellId: ${cellIdType}<TId>` + OR_UNDEFINED,
-        'descending: boolean',
-        'offset: number',
-        'limit: number' + OR_UNDEFINED,
-      ),
-      getParameterList('tableId', 'cellId', 'descending', 'offset', 'limit'),
-      1,
-      '<TId extends TableId>',
-    );
-    addProxyListener(
-      HAS + ROW,
-      hasRowListenerType,
-      getListenerDoc(5, 3, 0, 1),
-      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
-      'tableId, rowId',
-    );
-    addProxyListener(
-      ROW,
-      rowListenerType,
-      getListenerDoc(5, 3),
-      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
-      'tableId, rowId',
-    );
-    addProxyListener(
-      CELL_IDS,
-      cellIdsListenerType,
-      getListenerDoc(6, 5, 1),
-      `tableId: ${tableIdType} | null, rowId: IdOrNull`,
-      'tableId, rowId',
-    );
-    addProxyListener(
-      HAS + CELL,
-      hasCellListenerType,
-      getListenerDoc(7, 5, 0, 1),
-      `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${arrayJoin(
-        mapTablesSchema(
-          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
-        ),
-        ' | ',
-      )} | null`,
-      'tableId, rowId, cellId',
-    );
-    addProxyListener(
-      CELL,
-      cellListenerType,
-      getListenerDoc(7, 5),
-      `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${arrayJoin(
-        mapTablesSchema(
-          (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
-        ),
-        ' | ',
-      )} | null`,
-      'tableId, rowId, cellId',
-    );
-    addProxyListener(
-      INVALID + CELL,
-      invalidCellListenerType,
-      REGISTERS_A_LISTENER + ' whenever an invalid Cell change was attempted',
-      `tableId: IdOrNull, rowId: IdOrNull, cellId: IdOrNull`,
-      'tableId, rowId, cellId',
-    );
-    addImport(1, moduleDefinition, ...collValues(mapCellOrValueTypes));
-    arrayPush(
-      createSteps,
-      '.set' + TABLES + SCHEMA + '({',
-      flat(
-        mapTablesSchema((tableId, _, TABLE_ID) => [
-          `[${TABLE_ID}]: {`,
-          ...mapCellSchema(
-            tableId,
-            (_2, type, defaultValue, CELL_ID) =>
-              `[${CELL_ID}]: {[${addConstant(
-                snake(TYPE),
-                `'${TYPE}'`,
-              )}]: ${addConstant(snake(type), `'${type}'`)}${isUndefined(defaultValue) ? EMPTY_STRING : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` + (isString(defaultValue) ? addConstant(snake(defaultValue), `'${defaultValue}'`) : defaultValue)}},`,
-          ),
-          `},`,
-        ]),
-      ),
-      '})',
-    );
-  } else {
-    addImport(null, TINYBASE, TABLES);
-  }
-  if (!objIsEmpty(valuesSchema)) {
-    const [
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      _valueType,
-      valueCallbackType,
-      hasValuesListenerType,
-      valuesListenerType,
-      valueIdsListenerType,
-      hasValueListenerType,
-      valueListenerType,
-      invalidValueListenerType,
-    ] = getValuesTypes(storeInstance, storeType);
-    addImport(
-      1,
-      moduleDefinition,
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      valueCallbackType,
-      hasValuesListenerType,
-      valuesListenerType,
-      valueIdsListenerType,
-      hasValueListenerType,
-      valueListenerType,
-      invalidValueListenerType,
-    );
-    sharedValueTypes = [
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      hasValuesListenerType,
-      valuesListenerType,
-      valueIdsListenerType,
-      hasValueListenerType,
-      valueListenerType,
-    ];
-    arrayForEach(
-      [
-        [valuesType],
-        [BOOLEAN],
-        [storeType, 'values: ' + valuesWhenSetType, 'values'],
-        [storeType],
-        [storeType, 'partialValues: ' + valuesWhenSetType, 'partialValues'],
-      ],
-      ([returnType, params, paramsInCall], verb) =>
-        addProxyMethod(
-          verb,
-          EMPTY_STRING,
-          VALUES,
-          returnType,
-          getTheContentOfTheStoreDoc(2, verb),
-          params,
-          paramsInCall,
-        ),
-    );
-    addProxyMethod(
-      0,
-      EMPTY_STRING,
-      VALUE_IDS,
-      valueIdType + SQUARE_BRACKETS,
-      getIdsDoc(VALUE, THE_STORE),
-    );
-    addProxyMethod(
-      5,
-      EMPTY_STRING,
-      VALUE,
-      `void`,
-      getForEachDoc(VALUE, THE_STORE),
-      `valueCallback: ${valueCallbackType}`,
-      'valueCallback as any',
-    );
-    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
-      const mapValueType = 'Map' + camel(type, 1);
-      mapSet(mapCellOrValueTypes, type, mapValueType);
-      arrayForEach(
-        [
-          [type],
-          [BOOLEAN],
-          [storeType, `value: ${type} | ` + mapValueType, ', value as any'],
-          [storeType],
-        ],
-        ([returnType, params, paramsInCall = EMPTY_STRING], verb) =>
-          addProxyMethod(
-            verb,
-            valueName,
-            VALUE,
-            returnType,
-            getValueContentDoc(valueId, verb),
-            params,
-            VALUE_ID + paramsInCall,
-          ),
-      );
-    });
-    addProxyMethod(
-      0,
-      EMPTY_STRING,
-      VALUES + JSON$1,
-      JSON$1,
-      getTheContentOfTheStoreDoc(2, 6),
-    );
-    addProxyMethod(
-      2,
-      EMPTY_STRING,
-      VALUES + JSON$1,
-      storeType,
-      getTheContentOfTheStoreDoc(2, 7),
-      'valuesJson: ' + JSON$1,
-      'values' + JSON$1,
-    );
-    addProxyListener(
-      HAS + VALUES,
-      hasValuesListenerType,
-      getTheContentOfTheStoreDoc(2, 8, 0, 1) + ' changes',
-    );
-    addProxyListener(
-      VALUES,
-      valuesListenerType,
-      getTheContentOfTheStoreDoc(2, 8) + ' changes',
-    );
-    addProxyListener(VALUE_IDS, valueIdsListenerType, getListenerDoc(10, 0, 1));
-    addProxyListener(
-      HAS + VALUE,
-      hasValueListenerType,
-      getListenerDoc(11, 0, 0, 1),
-      `valueId: ${valueIdType} | null`,
-      'valueId',
-    );
-    addProxyListener(
-      VALUE,
-      valueListenerType,
-      getListenerDoc(11, 0),
-      `valueId: ${valueIdType} | null`,
-      'valueId',
-    );
-    addProxyListener(
-      INVALID + VALUE,
-      invalidValueListenerType,
-      REGISTERS_A_LISTENER + ' whenever an invalid Value change was attempted',
-      `valueId: IdOrNull`,
-      'valueId',
-    );
-    addImport(1, moduleDefinition, ...collValues(mapCellOrValueTypes));
-    addImport(0, TINYBASE, 'ValueChange');
-    arrayPush(
-      createSteps,
-      '.set' + VALUES + SCHEMA + '({',
-      mapValuesSchema((_, type, defaultValue, VALUE_ID) => [
-        `[${VALUE_ID}]: {[${addConstant(
-          snake(TYPE),
-          `'${TYPE}'`,
-        )}]: ${addConstant(snake(type), `'${type}'`)}${isUndefined(defaultValue) ? EMPTY_STRING : `, [${addConstant(snake(DEFAULT), `'${DEFAULT}'`)}]: ` + (isString(defaultValue) ? addConstant(snake(defaultValue), `'${defaultValue}'`) : defaultValue)}},`,
-      ]),
-      '})',
-    );
-  } else {
-    addImport(null, TINYBASE, VALUES);
-  }
-  addProxyMethod(
-    0,
-    EMPTY_STRING,
-    'Content',
-    `[${TABLES}, ${VALUES}]`,
-    getTheContentOfTheStoreDoc(0, 0),
-  );
-  addProxyMethod(
-    2,
-    EMPTY_STRING,
-    'Content',
-    storeType,
-    getTheContentOfTheStoreDoc(0, 2),
-    `[tables, values]: [${TABLES}, ${VALUES}]`,
-    '[tables, values]',
-  );
-  addProxyMethod(
-    2,
-    EMPTY_STRING,
-    TRANSACTION_CHANGES,
-    storeType,
-    `Applies a set of ${TRANSACTION_CHANGES} to the Store`,
-    'transactionChanges: ' + TRANSACTION_CHANGES,
-    'transactionChanges',
-  );
-  mapForEach(mapCellOrValueTypes, (type, mapCellType) =>
-    addType(
-      mapCellType,
-      `(cell: ${type}${OR_UNDEFINED}) => ` + type,
-      `Takes a ${type} Cell value and returns another`,
-    ),
-  );
-  addImport(
-    null,
-    TINYBASE,
-    'DoRollback',
-    ID,
-    'IdOrNull',
-    JSON$1,
-    'Store',
-    TRANSACTION_CHANGES,
-  );
-  addImport(0, TINYBASE, 'Get' + TRANSACTION_CHANGES, 'GetTransactionLog');
-  addProxyMethod(
-    0,
-    EMPTY_STRING,
-    JSON$1,
-    JSON$1,
-    getTheContentOfTheStoreDoc(0, 6),
-  );
-  addProxyMethod(
-    2,
-    EMPTY_STRING,
-    JSON$1,
-    storeType,
-    getTheContentOfTheStoreDoc(0, 7),
-    'tablesAndValuesJson: ' + JSON$1,
-    'tablesAndValuesJson',
-  );
-  addProxyMethod(
-    7,
-    EMPTY_STRING,
-    TRANSACTION_,
-    'Return',
-    TRANSACTION_DOC,
-    DO_ACTIONS_AND_ROLLBACK_PARAMS,
-    'actions, doRollback',
-    '<Return>',
-  );
-  addProxyMethod(
-    7,
-    EMPTY_STRING,
-    'start' + TRANSACTION,
-    storeType,
-    START_TRANSACTION_DOC,
-  );
-  addProxyMethod(
-    7,
-    EMPTY_STRING,
-    'finish' + TRANSACTION,
-    storeType,
-    FINISH_TRANSACTION_DOC,
-    DO_ROLLBACK_PARAM,
-    'doRollback',
-  );
-  const transactionListenerType = getTransactionListenerType(
-    storeInstance,
-    storeType,
-  );
-  addProxyListener(
-    'Start' + TRANSACTION,
-    transactionListenerType,
-    REGISTERS_A_LISTENER + ' just before the start of the ' + TRANSACTION_,
-    EMPTY_STRING,
-    EMPTY_STRING,
-    0,
-  );
-  addProxyListener(
-    'WillFinish' + TRANSACTION,
-    transactionListenerType,
-    REGISTERS_A_LISTENER + ' just before ' + THE_END_OF_THE_TRANSACTION,
-    EMPTY_STRING,
-    EMPTY_STRING,
-    0,
-  );
-  addProxyListener(
-    'DidFinish' + TRANSACTION,
-    transactionListenerType,
-    REGISTERS_A_LISTENER + ' just after ' + THE_END_OF_THE_TRANSACTION,
-    EMPTY_STRING,
-    EMPTY_STRING,
-    0,
-  );
-  addProxyMethod(
-    7,
-    EMPTY_STRING,
-    'call' + LISTENER,
-    storeType,
-    'Manually provoke a listener to be called',
-    'listenerId: Id',
-    'listenerId',
-  );
-  addProxyMethod(
-    3,
-    EMPTY_STRING,
-    LISTENER,
-    storeType,
-    'Remove a listener that was previously added to ' + THE_STORE,
-    'listenerId: Id',
-    'listenerId',
-  );
-  addMethod(
-    'getStore',
-    EMPTY_STRING,
-    'Store',
-    'store',
-    VERBS[0] + ' the underlying Store object',
-  );
-  addImport(1, TINYBASE, 'createStore');
-  addImport(
-    1,
-    moduleDefinition,
-    storeType,
-    `create${storeType} as create${storeType}Decl`,
-    transactionListenerType,
-  );
-  addConstant('store', ['createStore()', ...createSteps]);
-  addInternalFunction('fluent', 'actions: () => Store', [
-    'actions();',
-    `return ${storeInstance};`,
-  ]);
-  addInternalFunction(
-    'proxy',
-    `listener: any`,
-    `(_: Store, ...params: any[]) => listener(${storeInstance}, ...params)`,
-  );
-  addConstant(storeInstance, ['{', ...getMethods(1), '}']);
-  return [
-    build(
-      ...getImports(0),
-      ...getTypes(),
-      EXPORT + ' interface ' + storeType + ' {',
-      ...getMethods(0),
-      '}',
-      EMPTY_STRING,
-      comment(`Creates a ${storeType} object`),
-      EXPORT + ' function create' + storeType + '(): ' + storeType + ';',
-    ),
-    build(
-      ...getImports(1),
-      EXPORT +
-        ' const create' +
-        storeType +
-        ': typeof create' +
-        storeType +
-        'Decl = () => {',
-      ...getConstants(),
-      `return Object.freeze(${storeInstance});`,
-      '};',
-    ),
-    sharedTableTypes,
-    sharedValueTypes,
-  ];
-};
-
-const getGet = (noun) => GET + noun;
-const getGetAndGetDeps = (noun) =>
-  getParameterList(getGet(noun), getGet(noun) + DEPS);
-const DEBUG_IDS_PROP_TYPE = 'debugIds?: boolean';
-const DEBUG_IDS_PROP = 'debugIds={debugIds}';
-const THEN_DEPS = 'then' + DEPS_SUFFIX;
-const PARAMETER = 'Parameter';
-const GETTER_ARGS = ': (parameter: ' + PARAMETER + ', store: Store) => ';
-const USE_CONTEXT = 'const contextValue = useContext(Context);';
-const BASED_ON_A_PARAMETER = ', based on a parameter';
-const COLON_SPACE = ': ';
-const GENERIC_PARAMETER = '<' + PARAMETER + ',>';
-const PARAMETERIZED_CALLBACK =
-  PARAMETER + 'ized' + CALLBACK + '<' + PARAMETER + '>';
-const ROW_ID = 'rowId';
-const ROW_ID_PROP = 'rowId={rowId}';
-const SEPARATOR_AND_DEBUG_IDS = ', separator, debugIds';
-const SEPARATOR_PROP_TYPE = 'separator?: ReactElement | string';
-const THEN_PREFIX = 'then?: (store: Store';
-const THEN_AND_THEN_DEPS = getParameterList(
-  THEN_PREFIX + ')' + RETURNS_VOID,
-  THEN_DEPS,
-);
-const THEN_AND_THEN_DEPS_IN_CALL = 'then, then' + DEPS;
-const TYPED_ROW_ID = ROW_ID + COLON_SPACE + ID;
-const VIEW = 'View';
-const getListenerHookParams = (listenerType, ...extraParams) =>
-  getParameterList(
-    ...extraParams,
-    LISTENER_ + ': ' + listenerType,
-    LISTENER_ + DEPS_SUFFIX,
-    'mutator?: boolean',
-  );
-const getListenerHookParamsInCall = (...extraParams) =>
-  getParameterList(...extraParams, LISTENER_, LISTENER_ + DEPS, 'mutator');
-const getStoreUiReactApi = (
-  tablesSchema,
-  valuesSchema,
-  module,
-  sharedTableTypes,
-  sharedValueTypes,
-) => {
-  const [
-    build,
-    addImport,
-    addType,
-    addInternalFunction,
-    addConstant,
-    getImports,
-    getTypes,
-    getConstants,
-  ] = getCodeFunctions();
-  const [mapTablesSchema, mapCellSchema, mapValuesSchema] = getSchemaFunctions(
-    tablesSchema,
-    valuesSchema,
-    addConstant,
-  );
-  const moduleDefinition = `./${camel(module)}.d`;
-  const uiReactModuleDefinition = `./${camel(module)}-ui-react.d`;
-  const tinyBaseUiReact = 'tinybase/ui-react';
-  const storeType = camel(module, 1);
-  const storeInstance = camel(storeType);
-  const StoreOrStoreId = storeType + 'Or' + storeType + ID;
-  const storeOrStoreId = storeInstance + 'Or' + storeType + ID;
-  const storeProp = storeInstance + `={${storeInstance}}`;
-  const functions = mapNew();
-  const addFunction = (
-    name,
-    parameters,
-    returnType,
-    body,
-    doc,
-    generic = EMPTY_STRING,
-  ) => {
-    addImport(1, uiReactModuleDefinition, name + ' as ' + name + 'Decl');
-    return mapUnique(functions, name, [
-      parameters,
-      returnType,
-      body,
-      doc,
-      generic,
-    ]);
-  };
-  const addHook = (
-    name,
-    parameters,
-    returnType,
-    body,
-    doc,
-    generic = EMPTY_STRING,
-  ) => addFunction(`use${name}`, parameters, returnType, body, doc, generic);
-  const addProxyHook = (
-    name,
-    underlyingName,
-    returnType,
-    doc,
-    preParameters = EMPTY_STRING,
-    preParametersInCall = EMPTY_STRING,
-    generic = EMPTY_STRING,
-    postParameters = EMPTY_STRING,
-    postParametersInCall = EMPTY_STRING,
-  ) => {
-    addImport(
-      1,
-      tinyBaseUiReact,
-      `use${underlyingName} as use${underlyingName}Core`,
-    );
-    return addHook(
-      name,
-      getParameterList(preParameters, storeOrStoreIdParameter, postParameters),
-      returnType,
-      useHook +
-        `(${storeOrStoreId}, use${underlyingName}Core, [` +
-        (preParametersInCall ? preParametersInCall : EMPTY_STRING) +
-        (postParametersInCall ? '], [' + postParametersInCall : EMPTY_STRING) +
-        ']);',
-      doc,
-      generic,
-    );
-  };
-  const addComponent = (name, parameters, body, doc) =>
-    addFunction(name, parameters, 1, body, doc);
-  const getFunctions = (location = 0) =>
-    mapMap(functions, ([parameters, returnType, body, doc, generic], name) => {
-      const lines = location
-        ? [
-            EXPORT +
-              ` const ${name}: typeof ${name}Decl = ${generic}(${parameters}): ${returnType == 1 ? 'any' : returnType} =>`,
-            body,
-          ]
-        : [
-            EXPORT +
-              ` function ${name}${generic}(${parameters}): ${returnType == 1 ? 'ComponentReturnType' : returnType};`,
-          ];
-      if (!location) {
-        arrayUnshift(lines, comment(doc));
-      }
-      arrayPush(lines, EMPTY_STRING);
-      return lines;
-    });
-  addImport(
-    null,
-    TINYBASE,
-    ID,
-    'Store',
-    CALLBACK,
-    PARAMETER + 'ized' + CALLBACK,
-  );
-  addImport(0, tinyBaseUiReact, 'ComponentReturnType');
-  addImport(1, tinyBaseUiReact, 'useCellIds');
-  addImport(null, tinyBaseUiReact, 'ExtraProps');
-  addImport(0, moduleDefinition, storeType);
-  const storeOrStoreIdType = addType(
-    StoreOrStoreId,
-    storeType + ' | ' + ID,
-    `Used when you need to refer to a ${storeType} in a React hook or component`,
-  );
-  const providerPropsType = addType(
-    PROVIDER + PROPS,
-    getPropTypeList(
-      storeInstance + OPTIONAL_COLON + storeType,
-      storeInstance + `ById?: {[${storeInstance}Id: Id]: ${storeType}}`,
-    ),
-    `Used with the ${PROVIDER} component, so that a ` +
-      storeType +
-      ' can be passed into the context of an application',
-  );
-  addImport(0, 'react', 'ReactElement', 'ComponentType');
-  addImport(1, 'react', 'React');
-  addImport(1, uiReactModuleDefinition, storeOrStoreIdType, providerPropsType);
-  const storeOrStoreIdParameter =
-    storeOrStoreId + OPTIONAL_COLON + storeOrStoreIdType;
-  addConstant('{createContext, useContext, useMemo}', 'React');
-  addConstant(
-    'Context',
-    `createContext<[${storeType}?, {[${storeInstance}Id: Id]: ${storeType}}?]>([])`,
-  );
-  addHook(
-    `Create${storeType}`,
-    `create: () => ${storeType}, create` + DEPS_SUFFIX,
-    storeType,
-    '\n// eslint-disable-next-line react-hooks/exhaustive-deps\nuseMemo(create, createDeps)',
-    `Create a ${storeType} within a React application with convenient memoization`,
-  );
-  const getStoreHook = addHook(
-    storeType,
-    `id?: Id`,
-    storeType + OR_UNDEFINED,
-    [
-      '{',
-      USE_CONTEXT,
-      'return id == null ? contextValue[0] : contextValue[1]?.[id];',
-      '}',
-    ],
-    `Get a reference to a ${storeType} from within a ${PROVIDER} component context`,
-  );
-  const useHook = addInternalFunction(
-    `useHook`,
-    storeOrStoreId +
-      `: ${storeOrStoreIdType} | undefined, hook: (...params: any[]) => any, preParams: any[], postParams: any[] = []`,
-    [
-      `const ${storeInstance} = ${getStoreHook}(${storeOrStoreId} as Id);`,
-      `return hook(...preParams, ((${storeOrStoreId} == null || typeof ${storeOrStoreId} == 'string')`,
-      `? ${storeInstance} : ${storeOrStoreId})?.getStore(), ...postParams)`,
-    ],
-  );
-  const getProps = addInternalFunction(
-    'getProps',
-    'getProps: ((id: any) => ExtraProps) | undefined, id: Id',
-    '(getProps == null) ? ({} as ExtraProps) : getProps(id)',
-  );
-  const wrap = addInternalFunction(
-    'wrap',
-    getParameterList(
-      'children: any',
-      'separator?: any',
-      'encloseWithId?: boolean',
-      'id?: Id',
-    ),
-    [
-      'const separated = separator==null || !Array.isArray(children)',
-      ' ? children',
-      ' : children.map((child, c) => (c > 0 ? [separator, child] : child));',
-      `return encloseWithId ? [id, ':{', separated, '}'] : separated;`,
-    ],
-  );
-  const useCustomOrDefaultCellIds = addInternalFunction(
-    'useCustomOrDefaultCellIds',
-    getParameterList(
-      'customCellIds: Ids | undefined',
-      'tableId: Id',
-      'rowId: Id',
-      `${storeOrStoreId}?: ${storeOrStoreIdType} | undefined`,
-    ),
-    [
-      `const defaultCellIds = ${useHook}(${storeOrStoreId}, useCellIds, [tableId, rowId]);`,
-      'return customCellIds ?? defaultCellIds;',
-    ],
-  );
-  const NullComponent = addConstant('NullComponent', `() => null`);
-  if (!objIsEmpty(tablesSchema)) {
-    const [
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      cellIdType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      hasCellListenerType,
-      cellListenerType,
-      tablesTypes,
-    ] = sharedTableTypes;
-    addImport(
-      null,
-      moduleDefinition,
-      tablesType,
-      tablesWhenSetType,
-      tableIdType,
-      hasTablesListenerType,
-      tablesListenerType,
-      tableIdsListenerType,
-      hasTableListenerType,
-      tableListenerType,
-      tableCellIdsListenerType,
-      hasTableCellListenerType,
-      rowCountListenerType,
-      rowIdsListenerType,
-      sortedRowIdsListenerType,
-      hasRowListenerType,
-      rowListenerType,
-      cellIdsListenerType,
-      cellListenerType,
-      hasCellListenerType,
-    );
-    addImport(0, moduleDefinition, cellIdType);
-    addImport(1, moduleDefinition, storeType);
-    addImport(null, TINYBASE, IDS, 'IdOrNull');
-    const tableView = addInternalFunction(
-      'tableView',
-      `{${storeInstance}, rowComponent, getRowComponentProps, customCellIds` +
-        SEPARATOR_AND_DEBUG_IDS +
-        '}: any, rowIds: Ids, tableId: Id, defaultRowComponent: React.ComponentType<any>',
-      [
-        'const Row = rowComponent ?? defaultRowComponent;',
-        `return ${wrap}(rowIds.map((rowId) => (`,
-        '<Row',
-        '{...' + getProps + '(getRowComponentProps, rowId)}',
-        'key={rowId}',
-        'tableId={tableId}',
-        ROW_ID_PROP,
-        'customCellIds={customCellIds}',
-        storeProp,
-        DEBUG_IDS_PROP,
-        '/>',
-        '))',
-        SEPARATOR_AND_DEBUG_IDS,
-        ', tableId,',
-        ');',
-      ],
-    );
-    const getDefaultTableComponent = addInternalFunction(
-      'getDefaultTableComponent',
-      'tableId: Id',
-      arrayJoin(
-        mapTablesSchema(
-          (_, tableName, TABLE_ID) =>
-            `tableId == ${TABLE_ID} ? ${tableName}TableView : `,
-        ),
-      ) + NullComponent,
-    );
-    const getDefaultCellComponent = addInternalFunction(
-      'getDefaultCellComponent',
-      'tableId: Id, cellId: Id',
-      arrayJoin(
-        mapTablesSchema(
-          (tableId, tableName, TABLE_ID) =>
-            `tableId == ${TABLE_ID} ? ${
-              arrayJoin(
-                mapCellSchema(
-                  tableId,
-                  (_, _2, _3, CELL_ID, cellName) =>
-                    `cellId == ${CELL_ID} ? ` +
-                    tableName +
-                    cellName +
-                    'CellView : ',
-                ),
-              ) + NullComponent
-            } : `,
-        ),
-      ) + NullComponent,
-    );
-    addProxyHook(
-      HAS + TABLES,
-      HAS + TABLES,
-      BOOLEAN,
-      getTheContentOfTheStoreDoc(1, 0, 0, 1) + AND_REGISTERS,
-    );
-    addProxyHook(
-      TABLES,
-      TABLES,
-      tablesType,
-      getTheContentOfTheStoreDoc(1, 0) + AND_REGISTERS,
-    );
-    const useTableIds = addProxyHook(
-      TABLE_IDS,
-      TABLE_IDS,
-      tableIdType + SQUARE_BRACKETS,
-      getIdsDoc(TABLE, THE_STORE) + AND_REGISTERS,
-    );
-    addProxyHook(
-      SET + TABLES + CALLBACK,
-      SET + TABLES + CALLBACK,
-      PARAMETERIZED_CALLBACK,
-      getTheContentOfTheStoreDoc(1, 9) + BASED_ON_A_PARAMETER,
-      getParameterList(
-        getGet(TABLES) + GETTER_ARGS + tablesWhenSetType,
-        getGet(TABLES) + DEPS_SUFFIX,
-      ),
-      getGetAndGetDeps(TABLES),
-      GENERIC_PARAMETER,
-      getParameterList(
-        THEN_PREFIX,
-        `tables: ${tablesWhenSetType})` + RETURNS_VOID,
-        THEN_DEPS,
-      ),
-      THEN_AND_THEN_DEPS_IN_CALL,
-    );
-    addProxyHook(
-      DEL + TABLES + CALLBACK,
-      DEL + TABLES + CALLBACK,
-      CALLBACK,
-      getTheContentOfTheStoreDoc(1, 12),
-      EMPTY_STRING,
-      EMPTY_STRING,
-      EMPTY_STRING,
-      THEN_AND_THEN_DEPS,
-      THEN_AND_THEN_DEPS_IN_CALL,
-    );
-    const cellPropsType = addType(
-      CELL + PROPS,
-      getPropTypeList(
-        'tableId?: TId',
-        'rowId: Id',
-        'cellId?: CId',
-        storeInstance + OPTIONAL_COLON + storeType,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(A + CELL),
-      `<TId extends ${tableIdType}, CId extends ${cellIdType}<TId>>`,
-    );
-    const rowPropsType = addType(
-      ROW + PROPS,
-      getPropTypeList(
-        `tableId?: TId`,
-        'rowId: Id',
-        storeInstance + OPTIONAL_COLON + storeType,
-        'cellComponents?: {readonly [CId in ' +
-          cellIdType +
-          `<TId>]?: ComponentType<${cellPropsType}<TId, CId>>;}`,
-        `getCellComponentProps?: (cellId: ${cellIdType}<TId>) => ExtraProps`,
-        `customCellIds?: ${cellIdType}<TId>[]`,
-        SEPARATOR_PROP_TYPE,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(A + ROW),
-      `<TId extends ${tableIdType}>`,
-    );
-    const tablePropsType = addType(
-      TABLE + PROPS,
-      getPropTypeList(
-        `tableId?: TId`,
-        storeInstance + OPTIONAL_COLON + storeType,
-        `rowComponent?: ComponentType<${rowPropsType}<TId>>`,
-        `getRowComponentProps?: (rowId: Id) => ExtraProps`,
-        `customCellIds?: CellId<TId>[]`,
-        SEPARATOR_PROP_TYPE,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(A + TABLE),
-      `<TId extends ${tableIdType}>`,
-    );
-    const sortedTablePropsType = addType(
-      'Sorted' + TABLE + PROPS,
-      getPropTypeList(
-        `tableId?: TId`,
-        'cellId?: ' + cellIdType + '<TId>',
-        'descending?: boolean',
-        'offset?: number',
-        'limit?: number',
-        storeInstance + OPTIONAL_COLON + storeType,
-        `rowComponent?: ComponentType<${rowPropsType}<TId>>`,
-        `getRowComponentProps?: (rowId: Id) => ExtraProps`,
-        `customCellIds?: CellId<TId>[]`,
-        SEPARATOR_PROP_TYPE,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(A + 'sorted ' + TABLE),
-      `<TId extends ${tableIdType}>`,
-    );
-    const tablesPropsType = addType(
-      TABLES + PROPS,
-      getPropTypeList(
-        storeInstance + OPTIONAL_COLON + storeType,
-        'tableComponents?: {readonly [TId in ' +
-          tableIdType +
-          `]?: ComponentType<${tablePropsType}<TId>>;}`,
-        `getTableComponentProps?: (tableId: ${tableIdType}) => ExtraProps`,
-        SEPARATOR_PROP_TYPE,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(getTheContentOfDoc(1, 1)),
-    );
-    addImport(
-      1,
-      uiReactModuleDefinition,
-      tablesPropsType,
-      tablePropsType,
-      sortedTablePropsType,
-      rowPropsType,
-      cellPropsType,
-    );
-    addComponent(
-      TABLES + VIEW,
-      '{' +
-        storeInstance +
-        ', tableComponents, getTableComponentProps' +
-        SEPARATOR_AND_DEBUG_IDS +
-        '}: ' +
-        tablesPropsType,
-      [
-        wrap + `(${useTableIds}(${storeInstance}).map((tableId) => {`,
-        'const Table = (tableComponents?.[tableId] ?? ' +
-          getDefaultTableComponent +
-          `(tableId)) as React.ComponentType<TableProps<typeof tableId>>;`,
-        'return <Table',
-        `{...${getProps}(getTableComponentProps, tableId)}`,
-        'tableId={tableId}',
-        'key={tableId}',
-        storeProp,
-        DEBUG_IDS_PROP,
-        '/>;',
-        '}), separator)',
-      ],
-      getTheContentOfTheStoreDoc(1, 13) + AND_REGISTERS,
-    );
-    mapTablesSchema((tableId, tableName, TABLE_ID) => {
-      const [
-        tableType,
-        tableWhenSetType,
-        rowType,
-        rowWhenSetType,
-        cellIdType2,
-      ] = mapGet(tablesTypes, tableId);
-      addImport(
-        null,
-        moduleDefinition,
-        tableType,
-        tableWhenSetType,
-        rowType,
-        rowWhenSetType,
-        cellIdType2,
-      );
-      addProxyHook(
-        HAS + tableName + TABLE,
-        HAS + TABLE,
-        BOOLEAN,
-        getTableContentDoc(tableId, 0, 1) + AND_REGISTERS,
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyHook(
-        tableName + TABLE,
-        TABLE,
-        tableType,
-        getTableContentDoc(tableId) + AND_REGISTERS,
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyHook(
-        tableName + TABLE + CELL_IDS,
-        TABLE + CELL_IDS,
-        IDS,
-        getIdsDoc(CELL, 'the whole of ' + getTableDoc(tableId)) + AND_REGISTERS,
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      addProxyHook(
-        tableName + ROW + COUNT,
-        ROW + COUNT,
-        NUMBER,
-        'Gets the number of Rows in ' + getTableDoc(tableId) + AND_REGISTERS,
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      const useRowIds = addProxyHook(
-        tableName + ROW_IDS,
-        ROW_IDS,
-        IDS,
-        getIdsDoc(ROW, getTableDoc(tableId)) + AND_REGISTERS,
-        EMPTY_STRING,
-        TABLE_ID,
-      );
-      const useSortedRowIds = addProxyHook(
-        tableName + SORTED_ROW_IDS,
-        SORTED_ROW_IDS,
-        IDS,
-        getIdsDoc(ROW, getTableDoc(tableId), 1) + AND_REGISTERS,
-        'cellId?: ' +
-          cellIdType2 +
-          ', descending?: boolean, offset?: number, limit?: number',
-        TABLE_ID + ', cellId, descending, offset, limit',
-      );
-      addProxyHook(
-        HAS + tableName + ROW,
-        HAS + ROW,
-        BOOLEAN,
-        getRowContentDoc(tableId, 0, 1) + AND_REGISTERS,
-        TYPED_ROW_ID,
-        getParameterList(TABLE_ID, ROW_ID),
-      );
-      addProxyHook(
-        tableName + ROW,
-        ROW,
-        rowType,
-        getRowContentDoc(tableId) + AND_REGISTERS,
-        TYPED_ROW_ID,
-        getParameterList(TABLE_ID, ROW_ID),
-      );
-      addProxyHook(
-        tableName + CELL_IDS,
-        CELL_IDS,
-        cellIdType2 + SQUARE_BRACKETS,
-        getIdsDoc(CELL, getRowDoc(tableId)) + AND_REGISTERS,
-        TYPED_ROW_ID,
-        getParameterList(TABLE_ID, ROW_ID),
-      );
-      addProxyHook(
-        SET + tableName + TABLE + CALLBACK,
-        SET + TABLE + CALLBACK,
-        PARAMETERIZED_CALLBACK,
-        getTableContentDoc(tableId, 9) + BASED_ON_A_PARAMETER,
-        getParameterList(
-          getGet(TABLE) + GETTER_ARGS + tableWhenSetType,
-          getGet(TABLE) + DEPS_SUFFIX,
-        ),
-        getParameterList(TABLE_ID, getGetAndGetDeps(TABLE)),
-        GENERIC_PARAMETER,
-        getParameterList(
-          THEN_PREFIX,
-          `table: ${tableWhenSetType})` + RETURNS_VOID,
-          THEN_DEPS,
-        ),
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addProxyHook(
-        DEL + tableName + TABLE + CALLBACK,
-        DEL + TABLE + CALLBACK,
-        CALLBACK,
-        getTableContentDoc(tableId, 12),
-        EMPTY_STRING,
-        TABLE_ID,
-        EMPTY_STRING,
-        THEN_AND_THEN_DEPS,
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addProxyHook(
-        SET + tableName + ROW + CALLBACK,
-        SET + ROW + CALLBACK,
-        PARAMETERIZED_CALLBACK,
-        getRowContentDoc(tableId, 9) + BASED_ON_A_PARAMETER,
-        getParameterList(
-          TYPED_ROW_ID,
-          getGet(ROW) + GETTER_ARGS + rowWhenSetType,
-          getGet(ROW) + DEPS_SUFFIX,
-        ),
-        getParameterList(TABLE_ID, ROW_ID, getGetAndGetDeps(ROW)),
-        GENERIC_PARAMETER,
-        getParameterList(
-          THEN_PREFIX,
-          `row: ${rowWhenSetType})` + RETURNS_VOID,
-          THEN_DEPS,
-        ),
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addProxyHook(
-        'Add' + tableName + ROW + CALLBACK,
-        'Add' + ROW + CALLBACK,
-        PARAMETERIZED_CALLBACK,
-        getRowContentDoc(tableId, 10) + BASED_ON_A_PARAMETER,
-        getParameterList(
-          getGet(ROW) + GETTER_ARGS + rowWhenSetType,
-          getGet(ROW) + DEPS_SUFFIX,
-        ),
-        getParameterList(TABLE_ID, getGetAndGetDeps(ROW)),
-        GENERIC_PARAMETER,
-        'then?: (' +
-          getParameterList(
-            TYPED_ROW_ID + OR_UNDEFINED,
-            'store: Store',
-            'row: ' + rowWhenSetType + ')' + RETURNS_VOID,
-            'then' + DEPS_SUFFIX,
-          ) +
-          ', reuseRowIds?: boolean',
-        THEN_AND_THEN_DEPS_IN_CALL + ', reuseRowIds',
-      );
-      addProxyHook(
-        SET + tableName + PARTIAL + ROW + CALLBACK,
-        SET + PARTIAL + ROW + CALLBACK,
-        PARAMETERIZED_CALLBACK,
-        getRowContentDoc(tableId, 11) + BASED_ON_A_PARAMETER,
-        getParameterList(
-          TYPED_ROW_ID,
-          getGet(PARTIAL + ROW) + GETTER_ARGS + rowWhenSetType,
-          getGet(PARTIAL + ROW) + DEPS_SUFFIX,
-        ),
-        getParameterList(TABLE_ID, ROW_ID, getGetAndGetDeps(PARTIAL + ROW)),
-        GENERIC_PARAMETER,
-        getParameterList(
-          THEN_PREFIX,
-          `partialRow: ${rowWhenSetType})` + RETURNS_VOID,
-          THEN_DEPS,
-        ),
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addProxyHook(
-        DEL + tableName + ROW + CALLBACK,
-        DEL + ROW + CALLBACK,
-        CALLBACK,
-        getRowContentDoc(tableId, 12),
-        TYPED_ROW_ID,
-        getParameterList(TABLE_ID, ROW_ID),
-        EMPTY_STRING,
-        THEN_AND_THEN_DEPS,
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      const rowView = addComponent(
-        tableName + ROW + VIEW,
-        '{rowId, ' +
-          storeInstance +
-          ', cellComponents, getCellComponentProps, customCellIds' +
-          SEPARATOR_AND_DEBUG_IDS +
-          `}: ${rowPropsType}<'${tableId}'>`,
-        [
-          wrap +
-            `(${useCustomOrDefaultCellIds}(customCellIds, ` +
-            TABLE_ID +
-            `, rowId, ${storeInstance}).map((cellId: ${cellIdType2}) => {`,
-          'const Cell = (cellComponents?.[cellId] ?? ' +
-            getDefaultCellComponent +
-            `(${TABLE_ID}, cellId)) as React.ComponentType<CellProps<typeof ` +
-            TABLE_ID +
-            ', typeof cellId>>;',
-          'return <Cell',
-          `{...${getProps}(getCellComponentProps, cellId)} `,
-          'key={cellId}',
-          `tableId={${TABLE_ID}}`,
-          ROW_ID_PROP,
-          'cellId={cellId}',
-          storeProp,
-          DEBUG_IDS_PROP,
-          '/>;',
-          '})' + SEPARATOR_AND_DEBUG_IDS + ', rowId)',
-        ],
-        getRowContentDoc(tableId, 13) + AND_REGISTERS,
-      );
-      addComponent(
-        tableName + 'Sorted' + TABLE + VIEW,
-        '{cellId, descending, offset, limit, ...props}: ' +
-          sortedTablePropsType +
-          `<'${tableId}'>`,
-        tableView +
-          '(props, ' +
-          useSortedRowIds +
-          `(cellId, descending, offset, limit, props.${storeInstance}), ${TABLE_ID}, ${rowView});`,
-        getTableContentDoc(tableId, 13) + ', sorted' + AND_REGISTERS,
-      );
-      addComponent(
-        tableName + TABLE + VIEW,
-        `props: ${tablePropsType}<'${tableId}'>`,
-        tableView +
-          '(props, ' +
-          useRowIds +
-          `(props.${storeInstance}), ${TABLE_ID}, ${rowView});`,
-        getTableContentDoc(tableId, 13) + AND_REGISTERS,
-      );
-      mapCellSchema(
-        tableId,
-        (cellId, type, defaultValue, CELL_ID, cellName) => {
-          const mapCellType = 'Map' + camel(type, 1);
-          addImport(0, moduleDefinition, mapCellType);
-          addImport(1, moduleDefinition, mapCellType);
-          addProxyHook(
-            HAS + tableName + cellName + TABLE + CELL,
-            HAS + TABLE + CELL,
-            BOOLEAN,
-            `Gets ${getHasDoc(1)}the '${cellId}' Cell anywhere in ` +
-              getTableDoc(tableId) +
-              AND_REGISTERS,
-            EMPTY_STRING,
-            getParameterList(TABLE_ID, CELL_ID),
-          );
-          addProxyHook(
-            HAS + tableName + cellName + CELL,
-            HAS + CELL,
-            BOOLEAN,
-            getCellContentDoc(tableId, cellId, 0, 1) + AND_REGISTERS,
-            TYPED_ROW_ID,
-            getParameterList(TABLE_ID, ROW_ID, CELL_ID),
-          );
-          const useCell = addProxyHook(
-            tableName + cellName + CELL,
-            CELL,
-            type + (isUndefined(defaultValue) ? OR_UNDEFINED : EMPTY_STRING),
-            getCellContentDoc(tableId, cellId) + AND_REGISTERS,
-            TYPED_ROW_ID,
-            getParameterList(TABLE_ID, ROW_ID, CELL_ID),
-          );
-          addProxyHook(
-            SET + tableName + cellName + CELL + CALLBACK,
-            SET + CELL + CALLBACK,
-            PARAMETERIZED_CALLBACK,
-            getCellContentDoc(tableId, cellId, 9) + BASED_ON_A_PARAMETER,
-            getParameterList(
-              TYPED_ROW_ID,
-              getGet(CELL) + GETTER_ARGS + type + ' | ' + mapCellType,
-              getGet(CELL) + DEPS_SUFFIX,
-            ),
-            getParameterList(TABLE_ID, ROW_ID, CELL_ID, getGetAndGetDeps(CELL)),
-            GENERIC_PARAMETER,
-            getParameterList(
-              THEN_PREFIX,
-              `cell: ${type} | ${mapCellType})` + RETURNS_VOID,
-              THEN_DEPS,
-            ),
-            THEN_AND_THEN_DEPS_IN_CALL,
-          );
-          addProxyHook(
-            DEL + tableName + cellName + CELL + CALLBACK,
-            DEL + CELL + CALLBACK,
-            CALLBACK,
-            getCellContentDoc(tableId, cellId, 12),
-            getParameterList(TYPED_ROW_ID, 'forceDel?: boolean'),
-            getParameterList(TABLE_ID, ROW_ID, CELL_ID, 'forceDel'),
-            EMPTY_STRING,
-            THEN_AND_THEN_DEPS,
-            THEN_AND_THEN_DEPS_IN_CALL,
-          );
-          addComponent(
-            tableName + cellName + CELL + VIEW,
-            `{rowId, ${storeInstance}, debugIds}: ` +
-              cellPropsType +
-              `<'${tableId}', '${cellId}'>`,
-            [
-              wrap +
-                `('' + ${useCell}(rowId, ` +
-                storeInstance +
-                `) ?? '', undefined, debugIds, ${CELL_ID})`,
-            ],
-            getCellContentDoc(tableId, cellId, 13) + AND_REGISTERS,
-          );
-        },
-      );
-    });
-    const cellIdsType = arrayJoin(
-      mapTablesSchema(
-        (tableId) => mapGet(tablesTypes, tableId)?.[4] ?? EMPTY_STRING,
-      ),
-      ' | ',
-    );
-    addProxyHook(
-      HAS + TABLES + LISTENER,
-      HAS + TABLES + LISTENER,
-      VOID,
-      getTheContentOfTheStoreDoc(1, 8, 0, 1) + ' changes',
-      getListenerHookParams(hasTablesListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      TABLES + LISTENER,
-      TABLES + LISTENER,
-      VOID,
-      getTheContentOfTheStoreDoc(1, 8) + ' changes',
-      getListenerHookParams(tablesListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      TABLE_IDS + LISTENER,
-      TABLE_IDS + LISTENER,
-      VOID,
-      getListenerDoc(2, 0, 1),
-      getListenerHookParams(tableIdsListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      HAS + TABLE + LISTENER,
-      HAS + TABLE + LISTENER,
-      VOID,
-      getListenerDoc(3, 0, 0, 1),
-      getListenerHookParams(
-        hasTableListenerType,
-        `tableId: ${tableIdType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId'),
-    );
-    addProxyHook(
-      TABLE + LISTENER,
-      TABLE + LISTENER,
-      VOID,
-      getListenerDoc(3, 0),
-      getListenerHookParams(
-        tableListenerType,
-        `tableId: ${tableIdType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId'),
-    );
-    addProxyHook(
-      TABLE + CELL_IDS + LISTENER,
-      TABLE + CELL_IDS + LISTENER,
-      VOID,
-      getListenerDoc(14, 3, 1),
-      getListenerHookParams(
-        tableCellIdsListenerType,
-        `tableId: ${tableIdType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId'),
-    );
-    addProxyHook(
-      HAS + TABLE + CELL + LISTENER,
-      HAS + TABLE + CELL + LISTENER,
-      VOID,
-      getListenerDoc(16, 3, 0, 1),
-      getListenerHookParams(
-        hasTableCellListenerType,
-        `tableId: ${tableIdType} | null`,
-        `cellId: ${cellIdsType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId', 'cellId'),
-    );
-    addProxyHook(
-      ROW + COUNT + LISTENER,
-      ROW + COUNT + LISTENER,
-      VOID,
-      getListenerDoc(15, 3),
-      getListenerHookParams(
-        rowCountListenerType,
-        `tableId: ${tableIdType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId'),
-    );
-    addProxyHook(
-      ROW_IDS + LISTENER,
-      ROW_IDS + LISTENER,
-      VOID,
-      getListenerDoc(4, 3, 1),
-      getListenerHookParams(
-        rowIdsListenerType,
-        `tableId: ${tableIdType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId'),
-    );
-    addProxyHook(
-      SORTED_ROW_IDS + LISTENER,
-      SORTED_ROW_IDS + LISTENER,
-      VOID,
-      getListenerDoc(13, 3, 1),
-      getListenerHookParams(
-        sortedRowIdsListenerType,
-        `tableId: ${tableIdType} | null`,
-        'cellId: ' + cellIdsType + OR_UNDEFINED,
-        'descending: boolean',
-        'offset: number',
-        'limit: number' + OR_UNDEFINED,
-      ),
-      getListenerHookParamsInCall(
-        'tableId',
-        'cellId',
-        'descending',
-        'offset',
-        'limit',
-      ),
-    );
-    addProxyHook(
-      HAS + ROW + LISTENER,
-      HAS + ROW + LISTENER,
-      VOID,
-      getListenerDoc(5, 3, 0, 1),
-      getListenerHookParams(
-        hasRowListenerType,
-        `tableId: ${tableIdType} | null`,
-        ROW_ID + `: IdOrNull`,
-      ),
-      getListenerHookParamsInCall('tableId', ROW_ID),
-    );
-    addProxyHook(
-      ROW + LISTENER,
-      ROW + LISTENER,
-      VOID,
-      getListenerDoc(5, 3),
-      getListenerHookParams(
-        rowListenerType,
-        `tableId: ${tableIdType} | null`,
-        ROW_ID + `: IdOrNull`,
-      ),
-      getListenerHookParamsInCall('tableId', ROW_ID),
-    );
-    addProxyHook(
-      CELL_IDS + LISTENER,
-      CELL_IDS + LISTENER,
-      VOID,
-      getListenerDoc(6, 5, 1),
-      getListenerHookParams(
-        cellIdsListenerType,
-        `tableId: ${tableIdType} | null`,
-        ROW_ID + `: IdOrNull`,
-      ),
-      getListenerHookParamsInCall('tableId', ROW_ID),
-    );
-    addProxyHook(
-      HAS + CELL + LISTENER,
-      HAS + CELL + LISTENER,
-      VOID,
-      getListenerDoc(7, 5, 0, 1),
-      getListenerHookParams(
-        hasCellListenerType,
-        `tableId: ${tableIdType} | null`,
-        ROW_ID + `: IdOrNull`,
-        `cellId: ${cellIdsType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId', ROW_ID, 'cellId'),
-    );
-    addProxyHook(
-      CELL + LISTENER,
-      CELL + LISTENER,
-      VOID,
-      getListenerDoc(7, 5),
-      getListenerHookParams(
-        cellListenerType,
-        `tableId: ${tableIdType} | null`,
-        ROW_ID + `: IdOrNull`,
-        `cellId: ${cellIdsType} | null`,
-      ),
-      getListenerHookParamsInCall('tableId', ROW_ID, 'cellId'),
-    );
-  }
-  if (!objIsEmpty(valuesSchema)) {
-    const [
-      valuesType,
-      valuesWhenSetType,
-      valueIdType,
-      hasValuesListenerType,
-      valuesListenerType,
-      valueIdsListenerType,
-      hasValueListenerType,
-      valueListenerType,
-    ] = sharedValueTypes;
-    addImport(null, moduleDefinition, ...sharedValueTypes);
-    addImport(1, moduleDefinition, storeType);
-    const getDefaultValueComponent = addInternalFunction(
-      'getDefaultValueComponent',
-      'valueId: Id',
-      arrayJoin(
-        mapValuesSchema(
-          (_, _2, _3, VALUE_ID, valueName) =>
-            `valueId == ${VALUE_ID} ? ` + valueName + 'ValueView : ',
-        ),
-      ) + NullComponent,
-    );
-    addProxyHook(
-      HAS + VALUES,
-      HAS + VALUES,
-      BOOLEAN,
-      getTheContentOfTheStoreDoc(2, 0, 0, 1) + AND_REGISTERS,
-    );
-    addProxyHook(
-      VALUES,
-      VALUES,
-      valuesType,
-      getTheContentOfTheStoreDoc(2, 0) + AND_REGISTERS,
-    );
-    const useValueIds = addProxyHook(
-      VALUE_IDS,
-      VALUE_IDS,
-      valueIdType + SQUARE_BRACKETS,
-      getIdsDoc(VALUE, THE_STORE) + AND_REGISTERS,
-    );
-    addProxyHook(
-      SET + VALUES + CALLBACK,
-      SET + VALUES + CALLBACK,
-      PARAMETERIZED_CALLBACK,
-      getTheContentOfTheStoreDoc(2, 9) + BASED_ON_A_PARAMETER,
-      getParameterList(
-        getGet(VALUES) + GETTER_ARGS + valuesWhenSetType,
-        getGet(VALUES) + DEPS_SUFFIX,
-      ),
-      getGetAndGetDeps(VALUES),
-      GENERIC_PARAMETER,
-      getParameterList(
-        THEN_PREFIX,
-        `values: ${valuesWhenSetType})` + RETURNS_VOID,
-        THEN_DEPS,
-      ),
-      THEN_AND_THEN_DEPS_IN_CALL,
-    );
-    addProxyHook(
-      SET + PARTIAL + VALUES + CALLBACK,
-      SET + PARTIAL + VALUES + CALLBACK,
-      PARAMETERIZED_CALLBACK,
-      getTheContentOfTheStoreDoc(2, 11) + BASED_ON_A_PARAMETER,
-      getParameterList(
-        getGet(PARTIAL + VALUES) + GETTER_ARGS + valuesWhenSetType,
-        getGet(PARTIAL + VALUES) + DEPS_SUFFIX,
-      ),
-      getGetAndGetDeps(PARTIAL + VALUES),
-      GENERIC_PARAMETER,
-      getParameterList(
-        THEN_PREFIX,
-        `partialValues: ${valuesWhenSetType})` + RETURNS_VOID,
-        THEN_DEPS,
-      ),
-      THEN_AND_THEN_DEPS_IN_CALL,
-    );
-    addProxyHook(
-      DEL + VALUES + CALLBACK,
-      DEL + VALUES + CALLBACK,
-      CALLBACK,
-      getTheContentOfTheStoreDoc(2, 12),
-      EMPTY_STRING,
-      EMPTY_STRING,
-      EMPTY_STRING,
-      THEN_AND_THEN_DEPS,
-      THEN_AND_THEN_DEPS_IN_CALL,
-    );
-    const valuePropsType = addType(
-      VALUE + PROPS,
-      getPropTypeList(
-        `valueId?: VId`,
-        storeInstance + OPTIONAL_COLON + storeType,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc('a Value'),
-      `<VId extends ${valueIdType}>`,
-    );
-    const valuesPropsType = addType(
-      VALUES + PROPS,
-      getPropTypeList(
-        storeInstance + OPTIONAL_COLON + storeType,
-        'valueComponents?: {readonly [VId in ' +
-          valueIdType +
-          `]?: ComponentType<${valuePropsType}<VId>>;}`,
-        `getValueComponentProps?: (valueId: ${valueIdType}) => ExtraProps`,
-        SEPARATOR_PROP_TYPE,
-        DEBUG_IDS_PROP_TYPE,
-      ),
-      getPropsDoc(getTheContentOfDoc(2, 1)),
-    );
-    addImport(1, uiReactModuleDefinition, valuesPropsType, valuePropsType);
-    addComponent(
-      VALUES + VIEW,
-      '{' +
-        storeInstance +
-        ', valueComponents, getValueComponentProps' +
-        SEPARATOR_AND_DEBUG_IDS +
-        '}: ' +
-        valuesPropsType,
-      [
-        wrap + `(${useValueIds}(${storeInstance}).map((valueId) => {`,
-        'const Value = valueComponents?.[valueId] ?? ' +
-          getDefaultValueComponent +
-          '(valueId);',
-        'return <Value',
-        `{...${getProps}(getValueComponentProps, valueId)}`,
-        'key={valueId}',
-        storeProp,
-        DEBUG_IDS_PROP,
-        '/>;',
-        '}), separator)',
-      ],
-      getTheContentOfTheStoreDoc(2, 13) + AND_REGISTERS,
-    );
-    mapValuesSchema((valueId, type, _, VALUE_ID, valueName) => {
-      const mapValueType = 'Map' + camel(type, 1);
-      addImport(0, moduleDefinition, mapValueType);
-      addImport(1, moduleDefinition, mapValueType);
-      addProxyHook(
-        HAS + valueName + VALUE,
-        HAS + VALUE,
-        BOOLEAN,
-        getValueContentDoc(valueId, 0, 1) + AND_REGISTERS,
-        EMPTY_STRING,
-        VALUE_ID,
-      );
-      const useValue = addProxyHook(
-        valueName + VALUE,
-        VALUE,
-        type,
-        getValueContentDoc(valueId) + AND_REGISTERS,
-        EMPTY_STRING,
-        VALUE_ID,
-      );
-      addProxyHook(
-        SET + valueName + VALUE + CALLBACK,
-        SET + VALUE + CALLBACK,
-        PARAMETERIZED_CALLBACK,
-        getValueContentDoc(valueId, 9) + BASED_ON_A_PARAMETER,
-        getParameterList(
-          getGet(VALUE) + GETTER_ARGS + type + ' | ' + mapValueType,
-          getGet(VALUE) + DEPS_SUFFIX,
-        ),
-        getParameterList(VALUE_ID, getGetAndGetDeps(VALUE)),
-        GENERIC_PARAMETER,
-        getParameterList(
-          THEN_PREFIX,
-          `value: ${type} | ${mapValueType})` + RETURNS_VOID,
-          THEN_DEPS,
-        ),
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addProxyHook(
-        DEL + valueName + VALUE + CALLBACK,
-        DEL + VALUE + CALLBACK,
-        CALLBACK,
-        getValueContentDoc(valueId, 12),
-        EMPTY_STRING,
-        VALUE_ID,
-        EMPTY_STRING,
-        THEN_AND_THEN_DEPS,
-        THEN_AND_THEN_DEPS_IN_CALL,
-      );
-      addComponent(
-        valueName + VALUE + VIEW,
-        `{${storeInstance}, debugIds}: ${valuePropsType}<'${valueId}'>`,
-        [
-          wrap +
-            `('' + ${useValue}(` +
-            storeInstance +
-            `) ?? '', undefined, debugIds, ${VALUE_ID})`,
-        ],
-        getValueContentDoc(valueId, 13) + AND_REGISTERS,
-      );
-    });
-    addProxyHook(
-      HAS + VALUES + LISTENER,
-      HAS + VALUES + LISTENER,
-      VOID,
-      getTheContentOfTheStoreDoc(2, 8, 0, 1) + ' changes',
-      getListenerHookParams(hasValuesListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      VALUES + LISTENER,
-      VALUES + LISTENER,
-      VOID,
-      getTheContentOfTheStoreDoc(2, 8) + ' changes',
-      getListenerHookParams(valuesListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      VALUE_IDS + LISTENER,
-      VALUE_IDS + LISTENER,
-      VOID,
-      getListenerDoc(10, 0, 1),
-      getListenerHookParams(valueIdsListenerType),
-      getListenerHookParamsInCall(),
-    );
-    addProxyHook(
-      HAS + VALUE + LISTENER,
-      HAS + VALUE + LISTENER,
-      VOID,
-      getListenerDoc(11, 0, 0, 1),
-      getListenerHookParams(
-        hasValueListenerType,
-        `valueId: ${valueIdType} | null`,
-      ),
-      getListenerHookParamsInCall('valueId'),
-    );
-    addProxyHook(
-      VALUE + LISTENER,
-      VALUE + LISTENER,
-      VOID,
-      getListenerDoc(11, 0),
-      getListenerHookParams(
-        valueListenerType,
-        `valueId: ${valueIdType} | null`,
-      ),
-      getListenerHookParamsInCall('valueId'),
-    );
-  }
-  addComponent(
-    PROVIDER,
-    `{${storeInstance}, ${storeInstance}ById, children}: ` +
-      providerPropsType +
-      ' & {children: React.ReactNode}',
-    [
-      '{',
-      USE_CONTEXT,
-      'return (',
-      '<Context.' + PROVIDER,
-      'value={useMemo(',
-      `() => [${storeInstance} ?? contextValue[0], {...contextValue[1], ...${storeInstance}ById}],`,
-      `[${storeInstance}, ${storeInstance}ById, contextValue],`,
-      ')}>',
-      '{children}',
-      `</Context.${PROVIDER}>`,
-      ');',
-      '}',
-    ],
-    'Wraps part of an application in a context that provides default objects to be used by hooks and components within',
-  );
-  return [
-    build(...getImports(0), ...getTypes(), ...getFunctions(0)),
-    build(...getImports(1), ...getConstants(), ...getFunctions(1)),
-  ];
-};
-
-const getStoreApi = (tablesSchema, valuesSchema, module) => {
-  if (objIsEmpty(tablesSchema) && objIsEmpty(valuesSchema)) {
-    return [EMPTY_STRING, EMPTY_STRING, EMPTY_STRING, EMPTY_STRING];
-  }
-  const [dTsCore, tsCore, sharedTableTypes, sharedValueTypes] = getStoreCoreApi(
-    tablesSchema,
-    valuesSchema,
-    module,
-  );
-  return [
-    dTsCore,
-    tsCore,
-    ...getStoreUiReactApi(
-      tablesSchema,
-      valuesSchema,
-      module,
-      sharedTableTypes,
-      sharedValueTypes,
-    ),
-  ];
-};
-
-const jsonParse = JSON.parse;
-
-const PRETTIER = 'prettier/';
-const PRETTIER_PLUGINS = PRETTIER + 'plugins/';
-const prettierConfig = {
-  parser: 'typescript',
-  singleQuote: true,
-  trailingComma: 'all',
-  bracketSpacing: false,
-  jsdocSingleLineComment: false,
-};
-const createTools = getCreateFunction((store) => {
-  const getStoreStats = (detail) => {
-    let totalTables = 0;
-    let totalRows = 0;
-    let totalCells = 0;
-    const tables = {};
-    store.forEachTable((tableId, forEachRow) => {
-      totalTables++;
-      let tableRows = 0;
-      let tableCells = 0;
-      const rows = {};
-      forEachRow((rowId, forEachCell) => {
-        tableRows++;
-        let rowCells = 0;
-        forEachCell(() => rowCells++);
-        tableCells += rowCells;
-        if (detail) {
-          rows[rowId] = {rowCells};
-        }
-      });
-      totalRows += tableRows;
-      totalCells += tableCells;
-      if (detail) {
-        tables[tableId] = {tableRows, tableCells, rows};
-      }
-    });
-    return {
-      totalTables,
-      totalRows,
-      totalCells,
-      totalValues: size(store.getValueIds()),
-      jsonLength: size(store.getJson()),
-      ...(detail ? {detail: {tables}} : {}),
-    };
-  };
-  const getStoreTablesSchema = () => {
-    const tablesSchema = jsonParse(store.getTablesSchemaJson());
-    if (
-      !objIsEmpty(tablesSchema) ||
-      arrayEvery(store.getTableIds(), (tableId) => {
-        const rowIds = store.getRowIds(tableId);
-        const cellsMeta = mapNew();
-        if (
-          arrayEvery(rowIds, (rowId) =>
-            arrayEvery(store.getCellIds(tableId, rowId), (cellId) => {
-              const value = store.getCell(tableId, rowId, cellId);
-              const cellMeta = mapEnsure(cellsMeta, cellId, () => [
-                getCellOrValueType(value),
-                mapNew(),
-                [0],
-                0,
-              ]);
-              const [type, values, [maxCount]] = cellMeta;
-              const count = mapEnsure(values, value, () => 0) + 1;
-              if (count > maxCount) {
-                cellMeta[2] = [count, value];
-              }
-              mapSet(values, value, count);
-              cellMeta[3]++;
-              return type == getCellOrValueType(value);
-            }),
-          )
-        ) {
-          tablesSchema[tableId] = {};
-          collForEach(cellsMeta, ([type, , [, maxValue], count], cellId) => {
-            tablesSchema[tableId][cellId] = {
-              [TYPE]: type,
-              ...(count == size(rowIds) ? {[DEFAULT]: maxValue} : {}),
-            };
-          });
-          return 1;
-        }
-      })
-    ) {
-      return tablesSchema;
-    }
-    return {};
-  };
-  const getStoreValuesSchema = () => {
-    const valuesSchema = jsonParse(store.getValuesSchemaJson());
-    if (objIsEmpty(valuesSchema)) {
-      store.forEachValue((valueId, value) => {
-        valuesSchema[valueId] = {
-          [TYPE]: getCellOrValueType(value),
-        };
-      });
-    }
-    return valuesSchema;
-  };
-  const getStoreApi$1 = (module) =>
-    getStoreApi(getStoreTablesSchema(), getStoreValuesSchema(), module);
-  const getPrettyStoreApi = async (module) => {
-    const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
-    const plugins = [];
-    let format;
-    try {
-      format = (await import(PRETTIER + 'standalone')).format;
-      arrayPush(
-        plugins,
-        await import(PRETTIER_PLUGINS + 'estree'),
-        await import(PRETTIER_PLUGINS + 'typescript'),
-      );
-    } catch (e) {
-      format = async (str) => str;
-    }
-    return await promiseAll(
-      arrayMap(getStoreApi$1(module), async (file, f) =>
-        formatJsDoc(
-          await format(file, {
-            ...prettierConfig,
-            plugins,
-            filepath: `_.${extensions[f]}`,
-          }),
-        ),
-      ),
-    );
-  };
-  const getStore = () => store;
-  const tools = {
-    getStoreStats,
-    getStoreTablesSchema,
-    getStoreValuesSchema,
-    getStoreApi: getStoreApi$1,
-    getPrettyStoreApi,
-    getStore,
-  };
-  return objFreeze(tools);
-});
-
-export {createTools};