atom.io 0.27.5 → 0.28.0

package/react-devtools/dist/index.js

@@ -1,266 +1,18 @@
-import { lazyLocalStorageEffect } from '../../dist/chunk-H6EDLPKH.js';
-import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-IW6WYRS7.js';
-import { JSON_TYPE_NAMES, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-AK23DRMD.js';
+import { pipe, ifDefined, isArray, isRecord, doesExtend, jsonRefinery, doNothing, isPlainObject, become, mapObject, delve } from '../../dist/chunk-D52JNVER.js';
+import { isJson as isJson$1 } from '../../dist/chunk-EUVKUTW3.js';
+import '../../dist/chunk-BX3MTH2Z.js';
+import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { selectorFamily, atom, atomFamily, undo, redo, getState } from 'atom.io';
-import { attachIntrospectionStates } from 'atom.io/introspection';
 import { useI, useO } from 'atom.io/react';
 import { motion, spring, LayoutGroup } from 'framer-motion';
 import { forwardRef, useRef, useState, useImperativeHandle, useLayoutEffect, Fragment as Fragment$1, Component, useId } from 'react';
+import { atom, atomFamily, undo, redo, getState } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
+import { attachIntrospectionStates, primitiveRefinery, prettyJson, discoverType } from 'atom.io/introspection';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { isJson } from 'atom.io/json';
+import { persistSync } from 'atom.io/web';
 
-// ../anvl/src/refinement/can-exist.ts
-var canExist = (_) => true;
-
-// ../anvl/src/refinement/cannot-exist.ts
-var cannotExist = (_) => false;
-
-// ../anvl/src/refinement/is-intersection.ts
-function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
-  const name = `(${refinements.map((r) => r?.name || `anon`).join(` & `)})`;
-  const _ = {
-    [name]: (input) => refinements.every(
-      (refinement) => (logging && console.log(
-        refinements.map((r) => r.name || `anon`).join(` & `),
-        `>`,
-        refinement.name || `anon`,
-        `:`,
-        refinement(input)
-      ), refinement(input))
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
-      ...refinements,
-      isTypeB
-    ])
-  });
-  return checkTypes;
-}
-var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
-
-// ../anvl/src/refinement/is-union.ts
-var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
-  const name = `(${refinements.map((r) => r?.name || `anon`).join(` | `)})`;
-  const _ = {
-    [name]: (input) => refinements.some(
-      (refinement) => (logging && console.log(
-        refinements.map((r) => r.name || `anon`).join(` | `),
-        `>`,
-        refinement.name ?? `anon`,
-        `:`,
-        refinement(input)
-      ), refinement(input))
-    )
-  };
-  const checkTypes = Object.assign(_[name], {
-    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
-  });
-  return checkTypes;
-};
-var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
-
-// ../anvl/src/primitive/index.ts
-var isString = (input) => {
-  return typeof input === `string`;
-};
-var isNumber = (input) => {
-  return typeof input === `number`;
-};
-var isBoolean = (input) => {
-  return typeof input === `boolean`;
-};
-
-// ../anvl/src/refinement/refine-json.ts
-var JSON_PROTOTYPES = [
-  `Array`,
-  `Boolean`,
-  `Number`,
-  `Object`,
-  `String`
-];
-var refineJsonType = (data) => data === null ? { type: `null`, data: null } : isBoolean(data) ? { type: `boolean`, data } : isNumber(data) ? { type: `number`, data } : isString(data) ? { type: `string`, data } : Array.isArray(data) ? { type: `array`, data } : isPlainObject(data) ? { type: `object`, data } : raiseError(
-  data === void 0 ? `undefined passed to refineJsonType. This is not valid JSON.` : `${stringifyJson(data)} with prototype "${Object.getPrototypeOf(data).constructor.name}" passed to refineJsonType. This is not valid JSON.`
-);
-var isJson = (input) => {
-  if (input === null) return true;
-  if (input === void 0) return false;
-  const prototype = Object.getPrototypeOf(input)?.constructor.name;
-  const refine = JSON_PROTOTYPES.includes(prototype);
-  return refine;
-};
-
-// ../anvl/src/refinement/refinery.ts
-var Refinery = class {
-  supported;
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (e) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (_) {
-        }
-      }
-    }
-    return null;
-  }
-};
-var jsonRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  object: isPlainObject,
-  array: (input) => Array.isArray(input),
-  null: (input) => input === null
-});
-var discoverType = (input) => {
-  if (input === void 0) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
-};
-
-// ../anvl/src/refinement/index.ts
-var isLiteral = (value) => (input) => input === value;
-var isWithin = (args) => (input) => args.includes(input);
-
-// ../anvl/src/tree/differ.ts
-function diffNumber(a, b) {
-  const sign = a < b ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
-  };
-}
-function diffString(a, b) {
-  const sign = a.length < b.length ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
-  };
-}
-function diffBoolean(a, b) {
-  return {
-    summary: `${a} \u2192 ${b}`
-  };
-}
-function diffObject(a, b, recurse) {
-  let summary = ``;
-  const added = [];
-  const removed = [];
-  const changed = [];
-  sprawl(a, (path, nodeA) => {
-    let key;
-    for (key of path) {
-      const nodeB = b[key];
-      if (nodeB === void 0) {
-        removed.push([key, JSON.stringify(nodeA)]);
-      } else {
-        const delta = recurse(nodeA, nodeB);
-        if (delta.summary !== `No Change`) {
-          changed.push([key, delta]);
-        }
-      }
-    }
-  });
-  sprawl(b, (path, nodeB) => {
-    let key;
-    for (key of path) {
-      const nodeA = a[key];
-      if (nodeA === void 0) {
-        added.push([key, JSON.stringify(nodeB)]);
-      }
-    }
-  });
-  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
-  return {
-    summary,
-    added,
-    removed,
-    changed
-  };
-}
-function diffArray(a, b, recurse) {
-  return diffObject(a, b, recurse);
-}
-var Differ = class {
-  leafRefinery;
-  treeRefinery;
-  leafDiffers;
-  treeDiffers;
-  constructor(leafRefinery, treeRefinery, diffFunctions) {
-    this.leafRefinery = leafRefinery;
-    this.treeRefinery = treeRefinery;
-    this.leafDiffers = {};
-    this.treeDiffers = {};
-    for (const key of Object.keys(leafRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.leafDiffers[key] = diffFunction;
-    }
-    for (const key of Object.keys(treeRefinery.supported)) {
-      const diffFunction = diffFunctions[key];
-      this.treeDiffers[key] = diffFunction;
-    }
-  }
-  diff(a, b) {
-    if (a === b) {
-      return { summary: `No Change` };
-    }
-    try {
-      if (JSON.stringify(a) === JSON.stringify(b)) {
-        return { summary: `No Change` };
-      }
-    } catch (thrown) {
-      console.error(`Error stringifying`, a, b);
-    }
-    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
-    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
-    if (aRefined !== null && bRefined !== null) {
-      if (aRefined.type === bRefined.type) {
-        if (aRefined.type in this.leafDiffers) {
-          const delta = this.leafDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data
-          );
-          return delta;
-        }
-        if (aRefined.type in this.treeDiffers) {
-          const delta = this.treeDiffers[aRefined.type](
-            aRefined.data,
-            bRefined.data,
-            (x, y) => this.diff(x, y)
-          );
-          return delta;
-        }
-      }
-    }
-    const typeA = discoverType(a);
-    const typeB = discoverType(b);
-    if (typeA === typeB) {
-      return {
-        summary: `${typeA} \u2192 ${typeB}`
-      };
-    }
-    return {
-      summary: `Type change: ${typeA} \u2192 ${typeB}`
-    };
-  }
-};
 var OpenClose = ({ isOpen, setIsOpen, disabled, testid }) => {
   return /* @__PURE__ */ jsx(
     "button",
@@ -523,8 +275,11 @@ var JsonEditor_INTERNAL = ({
   Header: HeaderDisplay,
   Components
 }) => {
-  const dataIsJson = isJson(data);
-  const refined = dataIsJson ? refineJsonType(data) : { type: `non-json`, data };
+  const dataIsJson = isJson$1(data);
+  const refined = jsonRefinery.refine(data) ?? {
+    type: `non-json`,
+    data
+  };
   const SubEditor = dataIsJson ? SubEditors[refined.type] : NonJsonEditor;
   const disabled = isReadonly(path);
   return isHidden(path) ? null : /* @__PURE__ */ jsx(Components.ErrorBoundary, { children: /* @__PURE__ */ jsxs(Components.EditorWrapper, { className, style, children: [
@@ -609,6 +364,90 @@ var ArrayEditor = ({
   }) });
 };
 
+// ../anvl/src/json/index.ts
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+// ../anvl/src/primitive/index.ts
+var isString = (input) => {
+  return typeof input === `string`;
+};
+var isNumber = (input) => {
+  return typeof input === `number`;
+};
+var isBoolean = (input) => {
+  return typeof input === `boolean`;
+};
+
+// ../anvl/src/refinement/can-exist.ts
+var canExist = (_) => true;
+
+// ../anvl/src/refinement/cannot-exist.ts
+var cannotExist = (_) => false;
+
+// ../anvl/src/refinement/is-intersection.ts
+function mustSatisfyAllOfTheFollowing(isTypeA, logging = false, refinements = [isTypeA]) {
+  const name = `(${refinements.map((r) => r?.name || `anon`).join(` & `)})`;
+  const _ = {
+    [name]: (input) => refinements.every(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` & `),
+        `>`,
+        refinement.name || `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    and: (isTypeB) => mustSatisfyAllOfTheFollowing(isTypeB, logging, [
+      ...refinements,
+      isTypeB
+    ])
+  });
+  return checkTypes;
+}
+var isIntersection = mustSatisfyAllOfTheFollowing(canExist);
+
+// ../anvl/src/refinement/is-union.ts
+var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r?.name || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` | `),
+        `>`,
+        refinement.name ?? `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => mustSatisfyOneOfTheFollowing(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
+
+// ../anvl/src/refinement/index.ts
+var isLiteral = (value) => (input) => input === value;
+var isWithin = (args) => (input) => args.includes(input);
+
 // ../anvl/src/json-schema/integer.ts
 var isInteger = (input) => Number.isInteger(input);
 var parseInteger = (input) => {
@@ -951,92 +790,150 @@ var nullToObject = () => ({});
 
 // ../anvl/src/refinement/smart-cast-json.ts
 var castToJson = (input) => {
-  const json = refineJsonType(input);
-  return {
-    to: {
-      array: () => {
-        switch (json.type) {
-          case `array`:
-            return json.data;
-          case `object`:
-            return objectToArray(json.data);
-          case `string`:
-            return stringToArray(json.data);
-          case `boolean`:
-            return booleanToArray(json.data);
-          case `number`:
-            return numberToArray(json.data);
-          case `null`:
-            return nullToArray();
+  const refined = jsonRefinery.refine(input);
+  switch (refined?.type) {
+    case `array`: {
+      const data = refined.data;
+      return {
+        get array() {
+          return data;
+        },
+        get boolean() {
+          return arrayToBoolean(data);
+        },
+        get number() {
+          return arrayToNumber(data);
+        },
+        get object() {
+          return arrayToObject(data);
+        },
+        get string() {
+          return arrayToString(data);
+        },
+        get null() {
+          return null;
         }
-      },
-      boolean: () => {
-        switch (json.type) {
-          case `array`:
-            return arrayToBoolean(json.data);
-          case `object`:
-            return objectToBoolean(json.data);
-          case `string`:
-            return stringToBoolean(json.data);
-          case `boolean`:
-            return json.data;
-          case `number`:
-            return numberToBoolean(json.data);
-          case `null`:
-            return nullToBoolean();
+      };
+    }
+    case `boolean`: {
+      const data = refined.data;
+      return {
+        get array() {
+          return booleanToArray(data);
+        },
+        get boolean() {
+          return data;
+        },
+        get number() {
+          return booleanToNumber(data);
+        },
+        get object() {
+          return booleanToObject(data);
+        },
+        get string() {
+          return booleanToString(data);
+        },
+        get null() {
+          return null;
         }
-      },
-      number: () => {
-        switch (json.type) {
-          case `array`:
-            return arrayToNumber(json.data);
-          case `object`:
-            return objectToNumber(json.data);
-          case `string`:
-            return stringToNumber(json.data);
-          case `boolean`:
-            return booleanToNumber(json.data);
-          case `number`:
-            return json.data;
-          case `null`:
-            return nullToNumber();
+      };
+    }
+    case `number`: {
+      const data = refined.data;
+      return {
+        get array() {
+          return numberToArray(data);
+        },
+        get boolean() {
+          return numberToBoolean(data);
+        },
+        get number() {
+          return data;
+        },
+        get object() {
+          return numberToObject(data);
+        },
+        get string() {
+          return numberToString(data);
+        },
+        get null() {
+          return null;
         }
-      },
-      object: () => {
-        switch (json.type) {
-          case `array`:
-            return arrayToObject(json.data);
-          case `object`:
-            return json.data;
-          case `string`:
-            return stringToObject(json.data);
-          case `boolean`:
-            return booleanToObject(json.data);
-          case `number`:
-            return numberToObject(json.data);
-          case `null`:
-            return nullToObject();
+      };
+    }
+    case `object`: {
+      const data = refined.data;
+      return {
+        get array() {
+          return objectToArray(data);
+        },
+        get boolean() {
+          return objectToBoolean(data);
+        },
+        get number() {
+          return objectToNumber(data);
+        },
+        get object() {
+          return data;
+        },
+        get string() {
+          return objectToString(data);
+        },
+        get null() {
+          return null;
         }
-      },
-      string: () => {
-        switch (json.type) {
-          case `array`:
-            return arrayToString(json.data);
-          case `object`:
-            return objectToString(json.data);
-          case `string`:
-            return json.data;
-          case `boolean`:
-            return booleanToString(json.data);
-          case `number`:
-            return numberToString(json.data);
-          case `null`:
-            return nullToString();
+      };
+    }
+    case `string`: {
+      const data = refined.data;
+      return {
+        get array() {
+          return stringToArray(data);
+        },
+        get boolean() {
+          return stringToBoolean(data);
+        },
+        get number() {
+          return stringToNumber(data);
+        },
+        get object() {
+          return stringToObject(data);
+        },
+        get string() {
+          return data;
+        },
+        get null() {
+          return null;
         }
-      },
-      null: () => null
+      };
     }
-  };
+    case `null`: {
+      refined.data;
+      return {
+        get array() {
+          return nullToArray();
+        },
+        get boolean() {
+          return nullToBoolean();
+        },
+        get number() {
+          return nullToNumber();
+        },
+        get object() {
+          return nullToObject();
+        },
+        get string() {
+          return nullToString();
+        },
+        get null() {
+          return null;
+        }
+      };
+    }
+    default:
+      console.error(`Could not handle input given to castToJson`);
+      throw new Error(`Could not handle input given to castToJson`);
+  }
 };
 
 // ../hamr/react-json-editor/src/editors-by-type/utilities/object-properties.ts
@@ -1075,7 +972,7 @@ var makePropertyRecasters = (data, set) => mapObject(
   (value, key) => (newType) => {
     set(() => ({
       ...data,
-      [key]: castToJson(value).to[newType]()
+      [key]: castToJson(value)[newType]
     }));
   }
 );
@@ -1224,7 +1121,7 @@ var BooleanEditor = ({
 ) });
 var NullEditor = ({
   Components
-}) => /* @__PURE__ */ jsx(Components.NullWrapper, { children: '" "' });
+}) => /* @__PURE__ */ jsx(Components.NullWrapper, { children: " " });
 var NumberEditor = ({
   path = [],
   isReadonly = () => false,
@@ -1333,7 +1230,7 @@ var DEFAULT_JSON_EDITOR_COMPONENTS = {
       children
     }
   ),
-  EditorWrapper: ({ children, className }) => /* @__PURE__ */ jsx("div", { className: `json_editor ` + className, children }),
+  EditorWrapper: ({ children, className }) => /* @__PURE__ */ jsx("div", { className: `json_editor` + (className ? ` ${className}` : ``), children }),
   EditorLayout: ({
     DeleteButton,
     Header,
@@ -1412,13 +1309,20 @@ var SubEditors = {
   object: ObjectEditor,
   string: StringEditor
 };
+var fallback = (fn, fallbackValue) => {
+  try {
+    return fn();
+  } catch (_) {
+    return fallbackValue;
+  }
+};
 var StateEditor = ({ token }) => {
   const set = useI(token);
   const data = useO(token);
   return isJson(data) ? /* @__PURE__ */ jsx(JsonEditor, { data, set, schema: true }) : /* @__PURE__ */ jsx("div", { className: "json_editor", children: /* @__PURE__ */ jsx(
     ElasticInput,
     {
-      value: data !== null && typeof data === `object` && `toJson` in data && typeof data.toJson === `function` ? JSON.stringify(data.toJson()) : data instanceof Set ? `Set { ${JSON.stringify([...data]).slice(1, -1)} }` : Object.getPrototypeOf(data).constructor.name + ` ` + fallback(() => JSON.stringify(data), `?`),
+      value: data === void 0 || data === null ? `` : typeof data === `object` && `toJson` in data && typeof data.toJson === `function` ? JSON.stringify(data.toJson()) : data instanceof Set ? `Set { ${JSON.stringify([...data]).slice(1, -1)} }` : Object.getPrototypeOf(data).constructor.name + ` ` + fallback(() => JSON.stringify(data), `?`),
       disabled: true
     }
   ) });
@@ -1447,19 +1351,34 @@ var StoreEditor = ({ token }) => {
   }
   return /* @__PURE__ */ jsx(StateEditor, { token });
 };
-var findStateTypeState = selectorFamily({
-  key: `\u{1F441}\u200D\u{1F5E8} State Type`,
-  get: (token) => ({ get }) => {
-    let state;
-    try {
-      state = get(token);
-    } catch (error) {
-      return `error`;
-    }
-    if (state === void 0) return `undefined`;
-    if (isJson(state)) return refineJsonType(state).type;
-    return Object.getPrototypeOf(state).constructor.name;
-  }
+var {
+  atomIndex,
+  selectorIndex,
+  transactionIndex,
+  transactionLogSelectors,
+  timelineIndex,
+  timelineSelectors,
+  typeSelectors
+} = attachIntrospectionStates();
+var devtoolsAreOpenState = atom({
+  key: `\u{1F441}\u200D\u{1F5E8} Devtools Are Open`,
+  default: true,
+  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `\u{1F441}\u200D\u{1F5E8} Devtools Are Open`)]
+});
+var devtoolsViewSelectionState = atom({
+  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Selection`,
+  default: `atoms`,
+  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `\u{1F441}\u200D\u{1F5E8} Devtools View`)]
+});
+var devtoolsViewOptionsState = atom({
+  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Options`,
+  default: [`atoms`, `selectors`, `transactions`, `timelines`],
+  effects: typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, `\u{1F441}\u200D\u{1F5E8} Devtools View Options`)]
+});
+var viewIsOpenAtoms = atomFamily({
+  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Is Open`,
+  default: false,
+  effects: (key) => typeof window === `undefined` ? [] : [persistSync(window.localStorage, JSON, key + `:view-is-open`)]
 });
 var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
   const setIsOpen = useI(isOpenState);
@@ -1506,8 +1425,8 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
   const setIsOpen = useI(isOpenState);
   const isOpen = useO(isOpenState);
   for (const [key, childNode] of node.familyMembers) {
-    findState(findViewIsOpenState, key);
-    findState(findStateTypeState, childNode.key);
+    findState(viewIsOpenAtoms, key);
+    findState(typeSelectors, childNode.key);
   }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsxs("header", { children: [
@@ -1528,8 +1447,8 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
       StateIndexNode,
       {
         node: childNode,
-        isOpenState: findState(findViewIsOpenState, childNode.key),
-        typeState: findState(findStateTypeState, childNode.key)
+        isOpenState: findState(viewIsOpenAtoms, childNode.key),
+        typeState: findState(typeSelectors, childNode.key)
       },
       key
     )) : null
@@ -1552,8 +1471,8 @@ var StateIndex = ({ tokenIndex }) => {
       StateIndexNode,
       {
         node,
-        isOpenState: findState(findViewIsOpenState, node.key),
-        typeState: findState(findStateTypeState, node.key)
+        isOpenState: findState(viewIsOpenAtoms, node.key),
+        typeState: findState(typeSelectors, node.key)
       },
       key
     );
@@ -1791,8 +1710,8 @@ var TimelineIndex = () => {
       TimelineLog,
       {
         token,
-        isOpenState: findState(findViewIsOpenState, token.key),
-        timelineState: findState(findTimelineState, token.key)
+        isOpenState: findState(viewIsOpenAtoms, token.key),
+        timelineState: findState(timelineSelectors, token.key)
       },
       token.key
     );
@@ -1845,8 +1764,8 @@ var TransactionIndex = () => {
       TransactionLog,
       {
         token,
-        isOpenState: findState(findViewIsOpenState, token.key),
-        logState: findState(findTransactionLogState, token.key)
+        isOpenState: findState(viewIsOpenAtoms, token.key),
+        logState: findState(transactionLogSelectors, token.key)
       },
       token.key
     );
@@ -1930,52 +1849,4 @@ var AtomIODevtools = () => {
   ] });
 };
 
-// react-devtools/src/index.ts
-var {
-  atomIndex,
-  selectorIndex,
-  transactionIndex,
-  findTransactionLogState,
-  timelineIndex,
-  findTimelineState
-} = attachIntrospectionStates();
-var devtoolsAreOpenState = atom({
-  key: `\u{1F441}\u200D\u{1F5E8} Devtools Are Open`,
-  default: true,
-  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools Are Open`)]
-});
-var devtoolsViewSelectionState = atom({
-  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Selection`,
-  default: `atoms`,
-  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View`)]
-});
-var devtoolsViewOptionsState = atom({
-  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Options`,
-  default: [`atoms`, `selectors`, `transactions`, `timelines`],
-  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8} Devtools View Options`)]
-});
-var findViewIsOpenState = atomFamily({
-  key: `\u{1F441}\u200D\u{1F5E8} Devtools View Is Open`,
-  default: false,
-  effects: (key) => [lazyLocalStorageEffect(key + `:view-is-open`)]
-});
-var primitiveRefinery = new Refinery({
-  number: (input) => typeof input === `number`,
-  string: (input) => typeof input === `string`,
-  boolean: (input) => typeof input === `boolean`,
-  null: (input) => input === null
-});
-var jsonTreeRefinery = new Refinery({
-  object: isPlainObject,
-  array: (input) => Array.isArray(input)
-});
-var prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
-  number: diffNumber,
-  string: diffString,
-  boolean: diffBoolean,
-  null: () => ({ summary: `No Change` }),
-  object: diffObject,
-  array: diffArray
-});
-
-export { AtomIODevtools, atomIndex, devtoolsAreOpenState, devtoolsViewOptionsState, devtoolsViewSelectionState, findTimelineState, findTransactionLogState, findViewIsOpenState, jsonTreeRefinery, prettyJson, primitiveRefinery, selectorIndex, timelineIndex, transactionIndex };
+export { AtomIODevtools };