atom.io 0.25.5 → 0.26.0

package/data/dist/index.cjs

@@ -1,953 +0,0 @@
-'use strict';
-
-var internal = require('atom.io/internal');
-var json = require('atom.io/json');
-var setRtx = require('atom.io/transceivers/set-rtx');
-
-// data/src/dict.ts
-function dict(findState, index, store = internal.IMPLICIT.STORE) {
-  return internal.createStandaloneSelector(
-    {
-      key: `${findState.key}Dict`,
-      get: ({ get }) => {
-        const keys = get(index);
-        return keys.reduce((acc, key) => {
-          acc[key] = get(internal.findInStore(findState, key, store));
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
-}
-
-// ../rel8/junction/src/junction.ts
-var Junction = class {
-  constructor(data, config) {
-    this.relations = /* @__PURE__ */ new Map();
-    this.contents = /* @__PURE__ */ new Map();
-    this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b, _c, _d;
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!(config == null ? void 0 : config.externalStore)) {
-      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-      this.contents = new Map(data.contents);
-    }
-    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
-    if (config == null ? void 0 : config.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config == null ? void 0 : config.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
-        for (const y of ys) this.addRelation(x, y);
-      }
-      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
-        this.setContent(contentKey, content);
-      }
-    }
-  }
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
-      }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
-      }
-    }
-  }
-  replaceRelationsUnsafely(a, bs) {
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      const bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  replaceRelationsSafely(a, bs) {
-    const aRelationsPrev = this.relations.get(a);
-    if (aRelationsPrev) {
-      for (const b of aRelationsPrev) {
-        const bRelations = this.relations.get(b);
-        if (bRelations) {
-          if (bRelations.size === 1) {
-            this.relations.delete(b);
-          } else {
-            bRelations.delete(a);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      let bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.add(a);
-      } else {
-        bRelations = /* @__PURE__ */ new Set([a]);
-        this.relations.set(b, bRelations);
-      }
-    }
-  }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
-  }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
-  }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
-  }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
-      contents: [...this.contents.entries()]
-    };
-  }
-  set(a, ...rest) {
-    var _a;
-    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
-    a = typeof a === `string` ? a : a[this.a];
-    switch (this.cardinality) {
-      case `1:1`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b) this.delete(bPrev, a);
-      }
-      case `1:n`: {
-        const aPrev = this.getRelatedKey(b);
-        if (aPrev && aPrev !== a) this.delete(aPrev, b);
-      }
-    }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
-    }
-    this.addRelation(a, b);
-    return this;
-  }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const bRelation of bRelations) {
-          this.delete(bRelation, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const aRelation of aRelations) {
-          this.delete(a, aRelation);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
-  }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        console.warn(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      for (const relation of relations) {
-        return relation;
-      }
-    }
-  }
-  replaceRelations(a, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const bs = hasContent ? Object.keys(relations) : relations;
-    if (config == null ? void 0 : config.reckless) {
-      this.replaceRelationsUnsafely(a, bs);
-    } else {
-      this.replaceRelationsSafely(a, bs);
-    }
-    if (hasContent) {
-      for (const b of bs) {
-        const contentKey = this.makeContentKey(a, b);
-        const content = relations[b];
-        this.setContent(contentKey, content);
-      }
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((aRelation) => {
-          var _a;
-          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
-        });
-      }
-    }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((bRelation) => {
-          var _a;
-          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
-        });
-      }
-    }
-    return [];
-  }
-  has(a, b) {
-    var _a;
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
-    }
-    return this.relations.has(a);
-  }
-};
-
-// data/src/join.ts
-function capitalize(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
-var Join = class _Join {
-  constructor(options, defaultContent, store = internal.IMPLICIT.STORE) {
-    this.molecules = /* @__PURE__ */ new Map();
-    this.store = store;
-    this.options = options;
-    this.defaultContent = defaultContent;
-    this.alternates = /* @__PURE__ */ new Map();
-    this.alternates.set(store.config.name, this);
-    this.store.miscResources.set(`join:${options.key}`, this);
-    this.toolkit = {
-      get: (...ps) => internal.getFromStore(...ps, store),
-      set: (...ps) => {
-        internal.setIntoStore(...ps, store);
-      },
-      find: (token, key) => internal.findInStore(token, key, store),
-      seek: (token, key) => internal.seekInStore(token, key, store),
-      json: (token) => internal.getJsonToken(token, store),
-      dispose: (...ps) => {
-        internal.disposeFromStore(...ps, store);
-      }
-    };
-    this.retrieve = (token, key) => {
-      const maybeToken = this.toolkit.seek(token, key);
-      if (maybeToken) {
-        return maybeToken;
-      }
-      const molecule = this.molecules.get(json.stringifyJson(key));
-      if (molecule) {
-        const family = internal.withdraw(token, store);
-        return internal.growMoleculeInStore(molecule, family, store);
-      }
-      if (store.config.lifespan === `immortal`) {
-        throw new internal.NotFoundError(token, key, store);
-      }
-      return internal.initFamilyMemberInStore(token, key, store);
-    };
-    const aSide = options.between[0];
-    const bSide = options.between[1];
-    const relatedKeysAtoms = internal.createMutableAtomFamily(
-      {
-        key: `${options.key}/relatedKeys`,
-        default: () => new setRtx.SetRTX(),
-        mutable: true,
-        fromJson: (json) => setRtx.SetRTX.fromJSON(json),
-        toJson: (set) => set.toJSON()
-      },
-      store
-    );
-    this.core = { findRelatedKeysState: relatedKeysAtoms };
-    const getRelatedKeys = ({ get }, key) => get(this.retrieve(relatedKeysAtoms, key));
-    const addRelation = (toolkit, a, b) => {
-      const { set } = toolkit;
-      const aKeysState = this.retrieve(relatedKeysAtoms, a);
-      const bKeysState = this.retrieve(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => aKeys.add(b));
-      set(bKeysState, (bKeys) => bKeys.add(a));
-    };
-    const deleteRelation = (toolkit, a, b) => {
-      const { set } = toolkit;
-      const aKeysState = this.retrieve(relatedKeysAtoms, a);
-      const bKeysState = this.retrieve(relatedKeysAtoms, b);
-      set(aKeysState, (aKeys) => {
-        aKeys.delete(b);
-        if (aKeys.size === 0) ;
-        return aKeys;
-      });
-      set(bKeysState, (bKeys) => {
-        bKeys.delete(a);
-        if (bKeys.size === 0) ;
-        return bKeys;
-      });
-    };
-    const replaceRelationsSafely = (toolkit, a, newRelationsOfA) => {
-      const { get, set } = toolkit;
-      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
-      const currentRelationsOfA = get(relationsOfAState);
-      for (const currentRelationB of currentRelationsOfA) {
-        const remainsRelated = newRelationsOfA.includes(currentRelationB);
-        if (remainsRelated) {
-          continue;
-        }
-        const relationsOfBState = this.retrieve(
-          relatedKeysAtoms,
-          currentRelationB
-        );
-        set(relationsOfBState, (relationsOfB) => {
-          relationsOfB.delete(a);
-          return relationsOfB;
-        });
-      }
-      set(relationsOfAState, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          nextRelationsOfA.clear();
-          for (const newRelationB of newRelationsOfA) {
-            const relationsOfB = getRelatedKeys(toolkit, newRelationB);
-            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
-            if (this.relations.cardinality === `1:n`) {
-              const previousOwnersToDispose = [];
-              for (const previousOwner of relationsOfB) {
-                if (previousOwner === a) {
-                  continue;
-                }
-                const previousOwnerRelations = getRelatedKeys(
-                  toolkit,
-                  previousOwner
-                );
-                previousOwnerRelations.delete(newRelationB);
-                if (previousOwnerRelations.size === 0) {
-                  previousOwnersToDispose.push(previousOwner);
-                }
-              }
-              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
-                relationsOfB.clear();
-              }
-              for (const previousOwner of previousOwnersToDispose) {
-                const sorted = [newRelationB, previousOwner].sort();
-                const compositeKey = `"${sorted[0]}:${sorted[1]}"`;
-                this.molecules.delete(compositeKey);
-              }
-            }
-            if (!newRelationBIsAlreadyRelated) {
-              relationsOfB.add(a);
-            }
-            nextRelationsOfA.add(newRelationB);
-          }
-          return true;
-        });
-        return relationsOfA;
-      });
-    };
-    const replaceRelationsUnsafely = (toolkit, a, newRelationsOfA) => {
-      const { set } = toolkit;
-      const relationsOfAState = this.retrieve(relatedKeysAtoms, a);
-      set(relationsOfAState, (relationsOfA) => {
-        relationsOfA.transaction((nextRelationsOfA) => {
-          for (const newRelationB of newRelationsOfA) {
-            nextRelationsOfA.add(newRelationB);
-          }
-          return true;
-        });
-        return relationsOfA;
-      });
-      for (const newRelationB of newRelationsOfA) {
-        const newRelationsBState = this.retrieve(relatedKeysAtoms, newRelationB);
-        set(newRelationsBState, (newRelationsB) => {
-          newRelationsB.add(a);
-          return newRelationsB;
-        });
-      }
-      return true;
-    };
-    const has = (toolkit, a, b) => {
-      const aKeys = getRelatedKeys(toolkit, a);
-      return b ? aKeys.has(b) : aKeys.size > 0;
-    };
-    const baseExternalStoreConfiguration = {
-      getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
-      addRelation: (a, b) => {
-        addRelation(this.toolkit, a, b);
-      },
-      deleteRelation: (a, b) => {
-        deleteRelation(this.toolkit, a, b);
-      },
-      replaceRelationsSafely: (a, bs) => {
-        replaceRelationsSafely(this.toolkit, a, bs);
-      },
-      replaceRelationsUnsafely: (a, bs) => {
-        replaceRelationsUnsafely(this.toolkit, a, bs);
-      },
-      has: (a, b) => has(this.toolkit, a, b)
-    };
-    let externalStore;
-    let contentAtoms;
-    let contentMolecules;
-    if (defaultContent) {
-      contentAtoms = internal.createRegularAtomFamily(
-        {
-          key: `${options.key}/content`,
-          default: defaultContent
-        },
-        store
-      );
-      const joinToken = {
-        key: options.key,
-        type: `join`,
-        a: options.between[0],
-        b: options.between[1],
-        cardinality: options.cardinality
-      };
-      contentMolecules = internal.createMoleculeFamily(
-        {
-          key: `${options.key}/content-molecules`,
-          new: class ContentMolecule {
-            constructor(toolkit, key) {
-              this.key = key;
-              toolkit.bond(joinToken, { as: null });
-            }
-          }
-        },
-        store
-      );
-      const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
-      const setContent = ({ set }, key, content) => {
-        set(this.retrieve(contentAtoms, key), content);
-      };
-      const deleteContent = (_, compositeKey) => {
-        const contentMolecule = store.molecules.get(`"${compositeKey}"`);
-        if (contentMolecule) {
-          this.toolkit.dispose(contentMolecule);
-          this.molecules.delete(`"${compositeKey}"`);
-        }
-      };
-      const externalStoreWithContentConfiguration = {
-        getContent: (contentKey) => {
-          const content = getContent(this.toolkit, contentKey);
-          return content;
-        },
-        setContent: (contentKey, content) => {
-          setContent(this.toolkit, contentKey, content);
-        },
-        deleteContent: (contentKey) => {
-          deleteContent(this.toolkit, contentKey);
-        }
-      };
-      externalStore = Object.assign(
-        baseExternalStoreConfiguration,
-        externalStoreWithContentConfiguration
-      );
-    } else {
-      externalStore = baseExternalStoreConfiguration;
-    }
-    const relations = new Junction(options, {
-      externalStore,
-      makeContentKey: (...args) => {
-        const sorted = args.sort();
-        const compositeKey = `${sorted[0]}:${sorted[1]}`;
-        const [m0, m1] = sorted.map(
-          (key) => this.molecules.get(json.stringifyJson(key))
-        );
-        if (store.config.lifespan === `immortal` && m0 && m1) {
-          const target = internal.newest(store);
-          const moleculeToken = internal.makeMoleculeInStore(
-            target,
-            [m0, m1],
-            contentMolecules,
-            compositeKey
-          );
-          this.molecules.set(
-            `"${compositeKey}"`,
-            internal.withdraw(moleculeToken, target)
-          );
-        }
-        return compositeKey;
-      }
-    });
-    const createSingleKeyStateFamily = () => internal.createSelectorFamily(
-      {
-        key: `${options.key}/singleRelatedKey`,
-        get: (key) => ({ get }) => {
-          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
-          const relatedKeys = get(relatedKeysState);
-          for (const relatedKey of relatedKeys) {
-            return relatedKey;
-          }
-          return null;
-        }
-      },
-      store
-    );
-    const getMultipleKeyStateFamily = () => {
-      return internal.createSelectorFamily(
-        {
-          key: `${options.key}/multipleRelatedKeys`,
-          get: (key) => ({ get }) => {
-            const jsonFamily = internal.getJsonFamily(relatedKeysAtoms, store);
-            const jsonState = this.retrieve(jsonFamily, key);
-            const json = get(jsonState);
-            return json.members;
-          }
-        },
-        store
-      );
-    };
-    const createSingleEntryStateFamily = () => internal.createSelectorFamily(
-      {
-        key: `${options.key}/singleRelatedEntry`,
-        get: (key) => ({ get }) => {
-          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
-          const relatedKeys = get(relatedKeysState);
-          for (const relatedKey of relatedKeys) {
-            const contentKey = relations.makeContentKey(key, relatedKey);
-            const contentState = this.retrieve(contentAtoms, contentKey);
-            const content = get(contentState);
-            return [relatedKey, content];
-          }
-          return null;
-        }
-      },
-      store
-    );
-    const getMultipleEntryStateFamily = () => internal.createSelectorFamily(
-      {
-        key: `${options.key}/multipleRelatedEntries`,
-        get: (key) => ({ get }) => {
-          const jsonFamily = internal.getJsonFamily(relatedKeysAtoms, store);
-          const jsonState = this.retrieve(jsonFamily, key);
-          const json = get(jsonState);
-          return json.members.map((relatedKey) => {
-            const contentKey = relations.makeContentKey(key, relatedKey);
-            const contentState = this.retrieve(contentAtoms, contentKey);
-            const content = get(contentState);
-            return [relatedKey, content];
-          });
-        }
-      },
-      store
-    );
-    switch (options.cardinality) {
-      case `1:1`: {
-        const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: findSingleRelatedKeyState,
-          [stateKeyB]: findSingleRelatedKeyState
-        };
-        let states;
-        if (defaultContent) {
-          const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
-          const contentStates = {
-            [entriesStateKeyA]: findSingleRelatedEntryState,
-            [entriesStateKeyB]: findSingleRelatedEntryState
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        break;
-      }
-      case `1:n`: {
-        const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: findSingleRelatedKeyState,
-          [stateKeyB]: findMultipleRelatedKeysState
-        };
-        let states;
-        if (defaultContent) {
-          const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: findSingleRelatedEntryState,
-            [entriesStateKeyB]: findMultipleRelatedEntriesState
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-        break;
-      }
-      default: {
-        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
-        const baseStates = {
-          [stateKeyA]: findMultipleRelatedKeysState,
-          [stateKeyB]: findMultipleRelatedKeysState
-        };
-        let states;
-        if (defaultContent) {
-          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
-            bSide
-          )}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
-            aSide
-          )}`;
-          const contentStates = {
-            [entriesStateKeyA]: findMultipleRelatedEntriesState,
-            [entriesStateKeyB]: findMultipleRelatedEntriesState
-          };
-          states = Object.assign(baseStates, contentStates);
-        } else {
-          states = baseStates;
-        }
-        this.relations = relations;
-        this.states = states;
-      }
-    }
-  }
-  transact(toolkit, run) {
-    const originalToolkit = this.toolkit;
-    this.toolkit = toolkit;
-    run(this);
-    this.toolkit = originalToolkit;
-  }
-  [Symbol.dispose]() {
-    this.alternates.delete(this.store.config.name);
-  }
-  in(store) {
-    const key = store.config.name;
-    const alternate = this.alternates.get(key);
-    if (alternate) {
-      return alternate;
-    }
-    const join2 = new _Join(this.options, this.defaultContent, store);
-    this.alternates.set(key, join2);
-    join2.alternates = this.alternates;
-    return join2;
-  }
-};
-function join(options, defaultContent, store = internal.IMPLICIT.STORE) {
-  const joins = getJoinMap(store);
-  joins.set(options.key, new Join(options, defaultContent, store));
-  const token = {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-  return token;
-}
-function getJoinMap(store) {
-  if (`joins` in store && store.joins instanceof Map) {
-    return store.joins;
-  }
-  const joins = /* @__PURE__ */ new Map();
-  store.joins = joins;
-  return joins;
-}
-function getJoin(token, store) {
-  var _a;
-  const joinMap = getJoinMap(store);
-  let myJoin = joinMap.get(token.key);
-  if (myJoin === void 0) {
-    const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
-    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (myJoin === void 0) {
-      throw new Error(
-        `Join "${token.key}" not found in store "${store.config.name}"`
-      );
-    }
-    joinMap.set(token.key, myJoin);
-  }
-  return myJoin;
-}
-function findRelationsInStore(token, key, store) {
-  const myJoin = getJoin(token, store);
-  let relations;
-  switch (token.cardinality) {
-    case `1:1`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keyBA]() {
-          const familyBA = myJoin.states[keyBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in myJoin.states) {
-        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entryAB]() {
-            const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entryBA]() {
-            const familyBA = myJoin.states[entryBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-      break;
-    }
-    case `1:n`: {
-      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keyAB]() {
-          const familyAB = myJoin.states[keyAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in myJoin.states) {
-        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entryAB]() {
-            const familyAB = myJoin.states[entryAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-      break;
-    }
-    case `n:n`: {
-      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
-      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
-      relations = {
-        get [keysAB]() {
-          const familyAB = myJoin.states[keysAB];
-          const state = myJoin.retrieve(familyAB, key);
-          return state;
-        },
-        get [keysBA]() {
-          const familyBA = myJoin.states[keysBA];
-          const state = myJoin.retrieve(familyBA, key);
-          return state;
-        }
-      };
-      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-      if (entriesAB in myJoin.states) {
-        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
-        Object.assign(relations, {
-          get [entriesAB]() {
-            const familyAB = myJoin.states[entriesAB];
-            const state = myJoin.retrieve(familyAB, key);
-            return state;
-          },
-          get [entriesBA]() {
-            const familyBA = myJoin.states[entriesBA];
-            const state = myJoin.retrieve(familyBA, key);
-            return state;
-          }
-        });
-      }
-    }
-  }
-  return relations;
-}
-function findRelations(token, key) {
-  return findRelationsInStore(token, key, internal.IMPLICIT.STORE);
-}
-function editRelationsInStore(token, change, store) {
-  const myJoin = getJoin(token, store);
-  const target = internal.newest(store);
-  if (internal.isChildStore(target)) {
-    const { toolkit } = target.transactionMeta;
-    myJoin.transact(toolkit, ({ relations }) => {
-      change(relations);
-    });
-  } else {
-    change(myJoin.relations);
-  }
-}
-function editRelations(token, change) {
-  editRelationsInStore(token, change, internal.IMPLICIT.STORE);
-}
-function getInternalRelationsFromStore(token, store) {
-  const myJoin = getJoin(token, store);
-  const family = myJoin.core.findRelatedKeysState;
-  return family;
-}
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, internal.IMPLICIT.STORE);
-}
-var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
-function struct(options, store = internal.IMPLICIT.STORE) {
-  const atoms = Object.keys(options.default).reduce((acc, key) => {
-    const atomName = options.key + capitalize2(key) + `State`;
-    acc[atomName] = internal.createRegularAtom(
-      {
-        key: `${options.key}.${key}`,
-        default: options.default[key]
-      },
-      void 0,
-      store
-    );
-    return acc;
-  }, {});
-  const structState = internal.createStandaloneSelector(
-    {
-      key: options.key,
-      get: ({ get }) => {
-        return Object.keys(options.default).reduce((acc, key) => {
-          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
-  return [atoms, structState];
-}
-var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
-var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
-function structFamily(options) {
-  const atoms = Object.keys(options.default).reduce((acc, subKey) => {
-    const atomFamilyName = nameFamily(options.key, subKey);
-    acc[atomFamilyName] = internal.createRegularAtomFamily(
-      {
-        key: `${options.key}.${subKey}`,
-        default: options.default[subKey]
-      },
-      internal.IMPLICIT.STORE
-    );
-    return acc;
-  }, {});
-  const findStructState = internal.createSelectorFamily(
-    {
-      key: options.key,
-      get: (id) => ({ find, get }) => {
-        return Object.keys(options.default).reduce((acc, subKey) => {
-          acc[subKey] = get(
-            find(atoms[nameFamily(options.key, subKey)], id)
-          );
-          return acc;
-        }, {});
-      }
-    },
-    internal.IMPLICIT.STORE
-  );
-  return [atoms, findStructState];
-}
-
-// data/src/until.ts
-function until(loadable, fallback) {
-  if (loadable instanceof Promise) {
-    return fallback;
-  }
-  return loadable;
-}
-
-exports.Join = Join;
-exports.dict = dict;
-exports.editRelations = editRelations;
-exports.editRelationsInStore = editRelationsInStore;
-exports.findRelations = findRelations;
-exports.findRelationsInStore = findRelationsInStore;
-exports.getInternalRelations = getInternalRelations;
-exports.getInternalRelationsFromStore = getInternalRelationsFromStore;
-exports.getJoin = getJoin;
-exports.getJoinMap = getJoinMap;
-exports.join = join;
-exports.struct = struct;
-exports.structFamily = structFamily;
-exports.until = until;