atom.io 0.19.0 → 0.19.2

package/dist/{chunk-CVBEVTM5.js → chunk-CC7IF7QF.js}

@@ -34,18 +34,6 @@ var doNothing = () => void 0;
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
-var isModifier = (validate) => (sample) => {
-  const sampleIsValid = validate(sample);
-  if (!sampleIsValid) {
-    throw new Error(`Invalid test case: JSON.stringify(${sample})`);
-  }
-  return (input) => {
-    if (typeof input !== `function`)
-      return false;
-    const testResult = input(sample);
-    return validate(testResult);
-  };
-};
 var pass = (...params) => (fn) => fn(...params);
 var raiseError = (message) => {
   throw new Error(message);
@@ -58,24 +46,11 @@ var fallback = (fn, fallbackValue) => {
   }
 };
 
-// ../anvl/src/array/venn.ts
-var includesAll = (items) => (array) => {
-  for (const item of items) {
-    if (!array.includes(item))
-      return false;
-  }
-  return true;
-};
-var comprises = (items) => (array) => includesAll(items)(array) && includesAll(array)(items);
-
 // ../anvl/src/array/index.ts
 var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
 var map = (f) => (a) => a.map(f);
 var every = (f = Boolean) => (a) => a.every(f);
 var allTrue = every((x) => x === true);
-var addTo = (a) => (x) => a.includes(x) ? a : [...a, x];
-var isEmptyArray = (input) => Array.isArray(input) && input.length === 0;
-var isOneOf = (...args) => (input) => args.includes(input);
 
 // ../anvl/src/nullish/index.ts
 var isUndefined = (input) => input === void 0;
@@ -103,7 +78,6 @@ var mob = (fn) => (obj) => mapObject(obj, fn);
 // ../anvl/src/object/refinement.ts
 var isNonNullObject = (input) => typeof input === `object` && input !== null;
 var isPlainObject = (input) => isNonNullObject(input) && Object.getPrototypeOf(input) === Object.prototype;
-var isEmptyObject = (input) => isPlainObject(input) && Object.keys(input).length === 0;
 var isRecord = (isKey, isValue) => (input) => isPlainObject(input) && Object.entries(input).every(([k, v]) => isKey(k) && isValue(v));
 var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
   const name = `{${recordToEntries(
@@ -132,20 +106,19 @@ var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
 };
 var ALLOW_EXTENSION = { allowExtraProperties: true };
 var doesExtend = (isValue) => hasProperties(isValue, ALLOW_EXTENSION);
-var DO_NOT_ALLOW_EXTENSION = { allowExtraProperties: false };
-var hasExactProperties = (isValue) => hasProperties(isValue, DO_NOT_ALLOW_EXTENSION);
 
 // ../anvl/src/object/sprawl.ts
 var sprawl = (tree, inspector) => {
   const walk = (path, node) => {
-    const inspect = (path2, node2) => {
-      const result2 = inspector(path2, node2);
+    var _a;
+    const inspect = (p, n) => {
+      const result2 = inspector(p, n);
       if (result2)
         return result2;
       return null;
     };
     const result = inspect(path, node);
-    if ((result == null ? void 0 : result.jobComplete) || (result == null ? void 0 : result.pathComplete)) {
+    if ((_a = result == null ? void 0 : result.jobComplete) != null ? _a : result == null ? void 0 : result.pathComplete) {
       return result;
     }
     const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
@@ -161,19 +134,9 @@ var sprawl = (tree, inspector) => {
 };
 
 // ../anvl/src/object/index.ts
-var treeShake = (shouldDiscard = isUndefined) => (obj) => {
-  const newObj = {};
-  const entries = Object.entries(obj);
-  for (const [key, val] of entries) {
-    if (!shouldDiscard(val, key)) {
-      newObj[key] = val;
-    }
-  }
-  return newObj;
-};
 var delve = (obj, path) => {
   const found = path.reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
   return found === void 0 ? new Error(`Not found`) : { found };
 };
 
-export { addTo, become, comprises, delve, doNothing, doesExtend, entriesToRecord, fallback, hasExactProperties, ifDefined, isArray, isEmptyArray, isEmptyObject, isModifier, isOneOf, isPlainObject, isRecord, map, mapObject, pipe, raiseError, recordToEntries, sprawl, treeShake };
+export { become, delve, doNothing, doesExtend, fallback, ifDefined, isArray, isPlainObject, isRecord, mapObject, pipe, raiseError, recordToEntries, sprawl };

package/dist/{chunk-WX2NCOZR.js → chunk-FTONNX2R.js}

@@ -167,16 +167,16 @@ var Junction = class {
     if (a === void 0 && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
+        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 b2 of aRelations) {
-          this.delete(a, b2);
+        for (const aRelation of aRelations) {
+          this.delete(a, aRelation);
         }
       }
     }
@@ -229,18 +229,18 @@ var Junction = class {
     if (a !== void 0 && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        return [...aRelations].map((b2) => {
+        return [...aRelations].map((aRelation) => {
           var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+          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((a2) => {
+        return [...bRelations].map((bRelation) => {
           var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
         });
       }
     }

package/dist/{chunk-7ZR244C2.js → chunk-MSCJWACE.js}

@@ -1,4 +1,4 @@
-import { Junction } from './chunk-WX2NCOZR.js';
+import { Junction } from './chunk-FTONNX2R.js';
 import { dispose } from 'atom.io';
 import { getFromStore, setIntoStore, findInStore, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
@@ -31,11 +31,13 @@ var Join = class _Join {
     this.alternates.set(store.config.name, this);
     this.transactors = {
       get: (token) => getFromStore(token, store),
-      set: (token, value) => setIntoStore(token, value, store),
+      set: (token, value) => {
+        setIntoStore(token, value, store);
+      },
       find: (token, key) => findInStore(token, key, store)
     };
-    const a = options.between[0];
-    const b = options.between[1];
+    const aSide = options.between[0];
+    const bSide = options.between[1];
     const relatedKeysAtoms = createMutableAtomFamily(
       {
         key: `${options.key}/relatedKeys`,
@@ -48,23 +50,23 @@ var Join = class _Join {
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
     const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
-    const addRelation = (transactors, a2, b2) => {
+    const addRelation = (transactors, a, b) => {
       const { set, find } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a2);
-      const bKeysState = find(relatedKeysAtoms, b2);
-      set(aKeysState, (aKeys) => aKeys.add(b2));
-      set(bKeysState, (bKeys) => bKeys.add(a2));
+      const aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => aKeys.add(b));
+      set(bKeysState, (bKeys) => bKeys.add(a));
     };
-    const deleteRelation = (transactors, a2, b2) => {
+    const deleteRelation = (transactors, a, b) => {
       const { find, set } = transactors;
-      const aKeysState = find(relatedKeysAtoms, a2);
-      const bKeysState = find(relatedKeysAtoms, b2);
-      set(aKeysState, (aKeys) => (aKeys.delete(b2), aKeys));
-      set(bKeysState, (bKeys) => (bKeys.delete(a2), bKeys));
+      const aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys));
+      set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys));
     };
-    const replaceRelationsSafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
       const { find, get, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       const currentRelationsOfA = get(relationsOfAState);
       for (const currentRelationB of currentRelationsOfA) {
         const remainsRelated = newRelationsOfA.includes(currentRelationB);
@@ -73,7 +75,7 @@ var Join = class _Join {
         }
         const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
         set(relationsOfBState, (relationsOfB) => {
-          relationsOfB.delete(a2);
+          relationsOfB.delete(a);
           return relationsOfB;
         });
       }
@@ -82,10 +84,10 @@ var Join = class _Join {
           nextRelationsOfA.clear();
           for (const newRelationB of newRelationsOfA) {
             const relationsOfB = getRelatedKeys(transactors, newRelationB);
-            const newRelationBIsAlreadyRelated = relationsOfB.has(a2);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
             if (this.relations.cardinality === `1:n`) {
               for (const previousOwner of relationsOfB) {
-                if (previousOwner === a2) {
+                if (previousOwner === a) {
                   continue;
                 }
                 const previousOwnerRelations = getRelatedKeys(
@@ -99,7 +101,7 @@ var Join = class _Join {
               }
             }
             if (!newRelationBIsAlreadyRelated) {
-              relationsOfB.add(a2);
+              relationsOfB.add(a);
             }
             nextRelationsOfA.add(newRelationB);
           }
@@ -108,9 +110,9 @@ var Join = class _Join {
         return relationsOfA;
       });
     };
-    const replaceRelationsUnsafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
       const { find, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       set(relationsOfAState, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
@@ -123,23 +125,31 @@ var Join = class _Join {
       for (const newRelationB of newRelationsOfA) {
         const newRelationsBState = find(relatedKeysAtoms, newRelationB);
         set(newRelationsBState, (newRelationsB) => {
-          newRelationsB.add(a2);
+          newRelationsB.add(a);
           return newRelationsB;
         });
       }
       return true;
     };
-    const has = (transactors, a2, b2) => {
-      const aKeys = getRelatedKeys(transactors, a2);
-      return b2 ? aKeys.has(b2) : aKeys.size > 0;
+    const has = (transactors, a, b) => {
+      const aKeys = getRelatedKeys(transactors, a);
+      return b ? aKeys.has(b) : aKeys.size > 0;
     };
     const baseExternalStoreConfiguration = {
       getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
-      addRelation: (a2, b2) => addRelation(this.transactors, a2, b2),
-      deleteRelation: (a2, b2) => deleteRelation(this.transactors, a2, b2),
-      replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(this.transactors, a2, bs),
-      replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(this.transactors, a2, bs),
-      has: (a2, b2) => has(this.transactors, a2, b2)
+      addRelation: (a, b) => {
+        addRelation(this.transactors, a, b);
+      },
+      deleteRelation: (a, b) => {
+        deleteRelation(this.transactors, a, b);
+      },
+      replaceRelationsSafely: (a, bs) => {
+        replaceRelationsSafely(this.transactors, a, bs);
+      },
+      replaceRelationsUnsafely: (a, bs) => {
+        replaceRelationsUnsafely(this.transactors, a, bs);
+      },
+      has: (a, b) => has(this.transactors, a, b)
     };
     let externalStore;
     let contentAtoms;
@@ -152,8 +162,12 @@ var Join = class _Join {
         store
       );
       const getContent = ({ find, get }, key) => get(find(contentAtoms, key));
-      const setContent = ({ find, set }, key, content) => set(find(contentAtoms, key), content);
-      const deleteContent = ({ find }, key) => dispose(find(contentAtoms, key));
+      const setContent = ({ find, set }, key, content) => {
+        set(find(contentAtoms, key), content);
+      };
+      const deleteContent = ({ find }, key) => {
+        dispose(find(contentAtoms, key));
+      };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
           const content = getContent(this.transactors, contentKey);
@@ -241,8 +255,8 @@ var Join = class _Join {
     switch (options.cardinality) {
       case `1:1`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findSingleRelatedKeyState
@@ -250,8 +264,8 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findSingleRelatedEntryState
@@ -267,8 +281,8 @@ var Join = class _Join {
       case `1:n`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -277,8 +291,10 @@ var Join = class _Join {
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -293,8 +309,8 @@ var Join = class _Join {
       }
       default: {
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findMultipleRelatedKeysState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -302,8 +318,12 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findMultipleRelatedEntriesState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -341,21 +361,21 @@ function getJoinMap(store) {
 function getJoin(token, store) {
   var _a;
   const joinMap = getJoinMap(store);
-  let join2 = joinMap.get(token.key);
-  if (join2 === void 0) {
+  let myJoin = joinMap.get(token.key);
+  if (myJoin === void 0) {
     const rootJoinMap = getJoinMap(IMPLICIT.STORE);
-    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (join2 === void 0) {
+    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, join2);
+    joinMap.set(token.key, myJoin);
   }
-  return join2;
+  return myJoin;
 }
 function findRelationsInStore(token, key, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   let relations;
   switch (token.cardinality) {
     case `1:1`: {
@@ -363,27 +383,27 @@ function findRelationsInStore(token, key, store) {
       const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keyBA]() {
-          const familyBA = join2.states[keyBA];
+          const familyBA = myJoin.states[keyBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entryBA]() {
-            const familyBA = join2.states[entryBA];
+            const familyBA = myJoin.states[entryBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -396,27 +416,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -429,27 +449,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keysAB]() {
-          const familyAB = join2.states[keysAB];
+          const familyAB = myJoin.states[keysAB];
           const state = findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = findInStore(familyBA, key, store);
           return state;
         }
       };
       const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-      if (entriesAB in join2.states) {
+      if (entriesAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entriesAB]() {
-            const familyAB = join2.states[entriesAB];
+            const familyAB = myJoin.states[entriesAB];
             const state = findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = findInStore(familyBA, key, store);
             return state;
           }
@@ -463,23 +483,23 @@ function findRelations(token, key) {
   return findRelationsInStore(token, key, IMPLICIT.STORE);
 }
 function editRelationsInStore(token, change, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   const target = newest(store);
   if (isChildStore(target)) {
     const { transactors } = target.transactionMeta;
-    join2.transact(transactors, ({ relations }) => {
+    myJoin.transact(transactors, ({ relations }) => {
       change(relations);
     });
   } else {
-    change(join2.relations);
+    change(myJoin.relations);
   }
 }
 function editRelations(token, change) {
   editRelationsInStore(token, change, IMPLICIT.STORE);
 }
 function getInternalRelationsFromStore(token, store) {
-  const join2 = getJoin(token, store);
-  const family = join2.core.findRelatedKeysState;
+  const myJoin = getJoin(token, store);
+  const family = myJoin.core.findRelatedKeysState;
   return family;
 }
 function getInternalRelations(token) {

package/dist/index.cjs

@@ -32,6 +32,7 @@ function atomFamily(options) {
 function dispose(token, store = Internal__namespace.IMPLICIT.STORE) {
   switch (token.type) {
     case `atom`:
+    case `mutable_atom`:
       Internal__namespace.deleteAtom(token, store);
       break;
     case `selector`:
@@ -111,11 +112,18 @@ var Silo = class {
     this.selectorFamily = (options) => Internal.createSelectorFamily(options, s);
     this.transaction = (options) => Internal.createTransaction(options, s);
     this.timeline = (options) => Internal.createTimeline(options, s);
+    this.findState = (token, key) => Internal.findInStore(token, key, s);
     this.getState = (token) => Internal.getFromStore(token, s);
-    this.setState = (token, newValue) => Internal.setIntoStore(token, newValue, s);
+    this.setState = (token, newValue) => {
+      Internal.setIntoStore(token, newValue, s);
+    };
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
-    this.undo = (token) => Internal.timeTravel(`undo`, token, s);
-    this.redo = (token) => Internal.timeTravel(`redo`, token, s);
+    this.undo = (token) => {
+      Internal.timeTravel(`undo`, token, s);
+    };
+    this.redo = (token) => {
+      Internal.timeTravel(`redo`, token, s);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Internal.IMPLICIT.STORE) {
@@ -134,11 +142,11 @@ function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Inte
 var timeline = (options) => {
   return Internal.createTimeline(options, Internal.IMPLICIT.STORE);
 };
-var redo = (timeline2) => {
-  Internal.timeTravel(`redo`, timeline2, Internal.IMPLICIT.STORE);
+var redo = (tl) => {
+  Internal.timeTravel(`redo`, tl, Internal.IMPLICIT.STORE);
 };
-var undo = (timeline2) => {
-  Internal.timeTravel(`undo`, timeline2, Internal.IMPLICIT.STORE);
+var undo = (tl) => {
+  Internal.timeTravel(`undo`, tl, Internal.IMPLICIT.STORE);
 };
 function transaction(options) {
   return Internal.createTransaction(options, Internal.IMPLICIT.STORE);