tinybase 6.0.0-beta.0 → 6.0.0-beta.2

package/umd/es6/tools/index.js

@@ -1,3484 +0,0 @@
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined'
-    ? factory(exports)
-    : typeof define === 'function' && define.amd
-      ? define(['exports'], factory)
-      : ((global =
-          typeof globalThis !== 'undefined' ? globalThis : global || self),
-        factory((global.TinyBaseTools = {})));
-})(this, function (exports) {
-  'use strict';
-
-  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 TRANSACTION = 'Transaction';
-  const PARTIAL = 'Partial';
-  const strSplit = (str, separator = EMPTY_STRING, limit) =>
-    str.split(separator, limit);
-
-  var __async$1 = (__this, __arguments, generator) => {
-    return new Promise((resolve, reject) => {
-      var fulfilled = (value) => {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var rejected = (value) => {
-        try {
-          step(generator.throw(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var step = (x) =>
-        x.done
-          ? resolve(x.value)
-          : Promise.resolve(x.value).then(fulfilled, rejected);
-      step((generator = generator.apply(__this, __arguments)).next());
-    });
-  };
-  const promise = Promise;
-  const isFiniteNumber = isFinite;
-  const isUndefined = (thing) => thing == void 0;
-  const ifNotUndefined = (value, then, otherwise) =>
-    isUndefined(value)
-      ? otherwise == null
-        ? void 0
-        : 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 = (promises) =>
-    __async$1(void 0, null, function* () {
-      return promise.all(promises);
-    });
-
-  const getCellOrValueType = (cellOrValue) => {
-    const type = getTypeOf(cellOrValue);
-    return isTypeStringOrBoolean(type) ||
-      (type == NUMBER && isFiniteNumber(cellOrValue))
-      ? 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 isObject = (obj) =>
-    !isUndefined(obj) &&
-    ifNotUndefined(
-      getPrototypeOf(obj),
-      (objPrototype) =>
-        objPrototype == object.prototype ||
-        isUndefined(getPrototypeOf(objPrototype)),
-
-      /* istanbul ignore next */
-      () => true,
-    );
-  const objIds = object.keys;
-  const objFreeze = object.freeze;
-  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) => {
-    var _a;
-    return (_a = coll == null ? void 0 : coll.has(keyOrValue)) != null
-      ? _a
-      : false;
-  };
-  const collValues = (coll) => {
-    var _a;
-    return [
-      ...((_a = coll == null ? void 0 : coll.values()) != null ? _a : []),
-    ];
-  };
-  const collForEach = (coll, cb) => (coll == null ? void 0 : coll.forEach(cb));
-  const collDel = (coll, keyOrValue) =>
-    coll == null ? void 0 : coll.delete(keyOrValue);
-
-  const mapNew = (entries) => new Map(entries);
-  const mapGet = (map, key) => (map == null ? void 0 : map.get(key));
-  const mapForEach = (map, cb) =>
-    collForEach(map, (value, key) => cb(key, value));
-  const mapMap = (coll, cb) => {
-    var _a;
-    return arrayMap(
-      [...((_a = coll == null ? void 0 : coll.entries()) != null ? _a : [])],
-      ([key, value]) => cb(value, key),
-    );
-  };
-  const mapSet = (map, key, value) =>
-    isUndefined(value)
-      ? (collDel(map, key), map)
-      : map == null
-        ? void 0
-        : map.set(key, value);
-  const mapEnsure = (map, key, getDefaultValue, hadExistingValue) => {
-    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 CHANGES = 'Changes';
-  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 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_ = 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 == null ? void 0 : 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(
-        strSplit(str, NON_ALPHANUMERIC),
-        (word, w) =>
-          (w > 0 || firstCap ? upper : lower)(slice(word, 0, 1)) +
-          slice(word, 1),
-      ),
-    );
-  const snake = (str) =>
-    upper(
-      arrayJoin(
-        strSplit(
-          str && !NON_ALPHA.test(str[0]) ? str : ' ' + str,
-          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 != null ? 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);
-      return thing;
-    };
-  };
-
-  const getSchemaFunctions = (tablesSchema, valuesSchema, addConstant) => {
-    const mapTablesSchema = (callback) =>
-      objToArray(tablesSchema, (_, tableId) =>
-        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})` + 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) => {
-            var _a, _b;
-            return (_b =
-              (_a = mapGet(tablesTypes, tableId)) == null ? void 0 : _a[4]) !=
-              null
-              ? _b
-              : 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) => {
-            var _a, _b;
-            return (_b =
-              (_a = mapGet(tablesTypes, tableId)) == null ? void 0 : _a[4]) !=
-              null
-              ? _b
-              : EMPTY_STRING;
-          }),
-          ' | ',
-        )} | null`,
-        'tableId, rowId, cellId',
-      );
-      addProxyListener(
-        CELL,
-        cellListenerType,
-        getListenerDoc(7, 5),
-        `tableId: ${tableIdType} | null, rowId: IdOrNull, cellId: ${arrayJoin(
-          mapTablesSchema((tableId) => {
-            var _a, _b;
-            return (_b =
-              (_a = mapGet(tablesTypes, tableId)) == null ? void 0 : _a[4]) !=
-              null
-              ? _b
-              : 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(
-      7,
-      EMPTY_STRING,
-      'applyChanges',
-      storeType,
-      `Applies a set of ${CHANGES} to the Store`,
-      'changes: ' + CHANGES,
-      'changes',
-    );
-    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',
-      CHANGES,
-    );
-    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) => {
-          var _a, _b;
-          return (_b =
-            (_a = mapGet(tablesTypes, tableId)) == null ? void 0 : _a[4]) !=
-            null
-            ? _b
-            : 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 +
-        ' & {readonly 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;
-
-  var __defProp = Object.defineProperty;
-  var __defProps = Object.defineProperties;
-  var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-  var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __propIsEnum = Object.prototype.propertyIsEnumerable;
-  var __defNormalProp = (obj, key, value) =>
-    key in obj
-      ? __defProp(obj, key, {
-          enumerable: true,
-          configurable: true,
-          writable: true,
-          value,
-        })
-      : (obj[key] = value);
-  var __spreadValues = (a, b) => {
-    for (var prop in b || (b = {}))
-      if (__hasOwnProp.call(b, prop)) __defNormalProp(a, prop, b[prop]);
-    if (__getOwnPropSymbols)
-      for (var prop of __getOwnPropSymbols(b)) {
-        if (__propIsEnum.call(b, prop)) __defNormalProp(a, prop, b[prop]);
-      }
-    return a;
-  };
-  var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-  var __async = (__this, __arguments, generator) => {
-    return new Promise((resolve, reject) => {
-      var fulfilled = (value) => {
-        try {
-          step(generator.next(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var rejected = (value) => {
-        try {
-          step(generator.throw(value));
-        } catch (e) {
-          reject(e);
-        }
-      };
-      var step = (x) =>
-        x.done
-          ? resolve(x.value)
-          : Promise.resolve(x.value).then(fulfilled, rejected);
-      step((generator = generator.apply(__this, __arguments)).next());
-    });
-  };
-  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 __spreadValues(
-        {
-          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] = __spreadValues(
-                {
-                  [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 = (module) =>
-      __async(void 0, null, function* () {
-        const extensions = ['d.ts', 'ts', 'd.ts', 'tsx'];
-        const plugins = [];
-        let format;
-        try {
-          format = (yield import(PRETTIER + 'standalone')).format;
-          arrayPush(
-            plugins,
-            yield import(PRETTIER_PLUGINS + 'estree'),
-            yield import(PRETTIER_PLUGINS + 'typescript'),
-          );
-        } catch (e) {
-          format = (str) =>
-            __async(void 0, null, function* () {
-              return str;
-            });
-        }
-        return yield promiseAll(
-          arrayMap(getStoreApi$1(module), (file, f) =>
-            __async(void 0, null, function* () {
-              return formatJsDoc(
-                yield format(
-                  file,
-                  __spreadProps(__spreadValues({}, prettierConfig), {
-                    plugins,
-                    filepath: `_.${extensions[f]}`,
-                  }),
-                ),
-              );
-            }),
-          ),
-        );
-      });
-    const getStore = () => store;
-    const tools = {
-      getStoreStats,
-      getStoreTablesSchema,
-      getStoreValuesSchema,
-      getStoreApi: getStoreApi$1,
-      getPrettyStoreApi,
-      getStore,
-    };
-    return objFreeze(tools);
-  });
-
-  exports.createTools = createTools;
-});