atom.io 0.3.0 → 0.4.0

package/react-devtools/dist/index.js

@@ -0,0 +1,1579 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 = (a2, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a2, prop, b2[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
+    }
+  return a2;
+};
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
+var __restKey = (key) => typeof key === "symbol" ? key : key + "";
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../src/react-devtools/index.ts
+var react_devtools_exports = {};
+__export(react_devtools_exports, {
+  AtomIODevtools: () => AtomIODevtools,
+  composeDevtools: () => composeDevtools
+});
+module.exports = __toCommonJS(react_devtools_exports);
+
+// ../src/react-devtools/AtomIODevtools.tsx
+var import_react7 = require("react");
+var import_atom = require("atom.io");
+var import_react8 = require("atom.io/react");
+var import_framer_motion = require("framer-motion");
+
+// ../src/react-devtools/TokenList.tsx
+var import_react6 = require("react");
+
+// ../../anvl/src/object/index.ts
+var import_function4 = require("fp-ts/function");
+
+// ../../anvl/src/object/refinement.ts
+var import_function2 = require("fp-ts/function");
+
+// ../../anvl/src/object/access.ts
+var access = (k) => Object.assign((obj) => obj[k], {
+  in: (obj) => obj[k]
+});
+
+// ../../anvl/src/object/entries.ts
+var recordToEntries = (obj) => Object.entries(obj);
+var entriesToRecord = (entries) => Object.fromEntries(entries);
+
+// ../../anvl/src/object/mapObject.ts
+var import_function = require("fp-ts/lib/function");
+
+// ../../anvl/src/array/index.ts
+var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
+var map = (f) => (a2) => a2.map(f);
+var every = (f = Boolean) => (a2) => a2.every(f);
+var allTrue = every((x) => x === true);
+
+// ../../anvl/src/object/mapObject.ts
+var mapObject = (obj, fn) => (0, import_function.pipe)(
+  obj,
+  recordToEntries,
+  map(([key, val]) => [key, fn(val, key)]),
+  entriesToRecord
+);
+var mob = (fn) => (obj) => mapObject(obj, fn);
+
+// ../../anvl/src/function/index.ts
+var doNothing = () => void 0;
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+var pass = (...params) => (fn) => fn(...params);
+var raiseError = (message) => {
+  throw new Error(message);
+};
+var attempt = (fn) => {
+  try {
+    fn();
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+// ../../anvl/src/nullish/index.ts
+var isUndefined = (input) => input === void 0;
+var ifDefined = (validate) => (input) => isUndefined(input) || validate(input);
+var ifNullish = (alt) => (input) => input != null ? input : alt;
+
+// ../../anvl/src/object/refinement.ts
+var isNonNullObject = (input) => typeof input === `object` && input !== null;
+var isPlainObject = (input) => isNonNullObject(input) && Object.getPrototypeOf(input) === Object.prototype;
+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(
+    isValue
+  ).map(([k, v]) => String(k) + `:` + v.name).join(`,`)}}`;
+  const _ = {
+    [name]: (input) => isPlainObject(input) && (0, import_function2.pipe)(
+      isValue,
+      Object.entries,
+      every(([key, val]) => key in input || val(void 0))
+    ) && (0, import_function2.pipe)(
+      input,
+      mob(
+        (val, key) => (0, import_function2.pipe)(
+          isValue,
+          access(key),
+          ifNullish(() => options.allowExtraProperties),
+          pass(val)
+        )
+      ),
+      Object.values,
+      allTrue
+    )
+  };
+  return _[name];
+};
+var doesExtend = (
+  /* alias for hasExactProperties with allowExtraProperties */
+  (isValue) => hasProperties(isValue, { allowExtraProperties: true })
+);
+
+// ../../anvl/src/object/index.ts
+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 };
+};
+
+// ../../anvl/src/json/index.ts
+var import_function6 = require("fp-ts/function");
+
+// ../../anvl/src/json/refine.ts
+var import_boolean = require("fp-ts/boolean");
+var import_number = require("fp-ts/number");
+var import_string = require("fp-ts/string");
+var refineJsonType = (data) => data === null ? { type: `null`, data: null } : (0, import_boolean.isBoolean)(data) ? { type: `boolean`, data } : (0, import_number.isNumber)(data) ? { type: `number`, data } : (0, import_string.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) => {
+  try {
+    JSON.stringify(input);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+var isPlainJson = (input) => attempt(() => isJson(input) && refineJsonType(input));
+
+// ../../anvl/src/json/index.ts
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+// ../../hamr/src/react-elastic-input/ElasticInput.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("@emotion/react/jsx-runtime");
+var ElasticInput = (0, import_react.forwardRef)(function ElasticInputFC(props, ref) {
+  var _a2, _b, _c, _d;
+  const inputRef = (0, import_react.useRef)(null);
+  const spanRef = (0, import_react.useRef)(null);
+  const [inputWidth, setInputWidth] = (0, import_react.useState)(`auto`);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    focus: () => {
+      var _a3;
+      (_a3 = inputRef.current) == null ? void 0 : _a3.focus();
+    }
+  }));
+  const extraWidth = props.type === `number` ? 15 : 0;
+  (0, import_react.useLayoutEffect)(() => {
+    if (spanRef.current) {
+      setInputWidth(`${spanRef.current.offsetWidth + extraWidth}px`);
+      const interval = setInterval(() => {
+        if (spanRef.current) {
+          setInputWidth(`${spanRef.current.offsetWidth + extraWidth}px`);
+        }
+      }, 1e3);
+      return () => clearInterval(interval);
+    }
+  }, [(_a2 = inputRef.current) == null ? void 0 : _a2.value, props.value]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { style: { display: `inline-block`, position: `relative` }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "input",
+      __spreadProps(__spreadValues({}, props), {
+        ref: inputRef,
+        style: __spreadValues({
+          padding: 0,
+          borderRadius: 0,
+          border: `none`,
+          fontFamily: `inherit`,
+          fontSize: `inherit`,
+          width: inputWidth
+        }, props.style)
+      })
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "span",
+      {
+        ref: spanRef,
+        style: {
+          padding: (_b = props.style) == null ? void 0 : _b.padding,
+          position: `absolute`,
+          visibility: `hidden`,
+          // color: `red`,
+          whiteSpace: `pre`,
+          fontFamily: ((_c = props.style) == null ? void 0 : _c.fontFamily) || `inherit`,
+          fontSize: ((_d = props.style) == null ? void 0 : _d.fontSize) || `inherit`
+        },
+        children: props.value
+      }
+    )
+  ] });
+});
+
+// ../../hamr/src/react-elastic-input/NumberInput.tsx
+var import_react2 = require("react");
+var import_function7 = require("fp-ts/function");
+
+// ../../anvl/src/number/clamp.ts
+var clampInto = ([min, max]) => (value) => value < min ? min : value > max ? max : value;
+
+// ../../hamr/src/react-elastic-input/NumberInput.tsx
+var import_jsx_runtime2 = require("@emotion/react/jsx-runtime");
+function round(value, decimalPlaces) {
+  if (decimalPlaces === void 0)
+    return value;
+  const factor = Math.pow(10, decimalPlaces);
+  return Math.round(value * factor) / factor;
+}
+var VALID_NON_NUMBERS = [``, `-`, `.`, `-.`];
+var isValidNonNumber = (input) => VALID_NON_NUMBERS.includes(input);
+var VALID_NON_NUMBER_INTERPRETATIONS = {
+  "": null,
+  "-": 0,
+  ".": 0,
+  "-.": 0
+};
+var isDecimalInProgress = (input) => input === `0` || !isNaN(Number(input)) && input.includes(`.`);
+var textToValue = (input, allowDecimal) => {
+  if (isValidNonNumber(input))
+    return VALID_NON_NUMBER_INTERPRETATIONS[input];
+  return allowDecimal ? parseFloat(input) : Math.round(parseFloat(input));
+};
+var DEFAULT_NUMBER_CONSTRAINTS = {
+  max: Infinity,
+  min: -Infinity,
+  decimalPlaces: 100,
+  nullable: true
+};
+var initRefinery = (constraints) => (input) => {
+  if (input === null && constraints.nullable === true) {
+    return null;
+  }
+  const { max, min, decimalPlaces } = __spreadValues(__spreadValues({}, DEFAULT_NUMBER_CONSTRAINTS), constraints);
+  const constrained = (0, import_function7.pipe)(
+    input != null ? input : 0,
+    clampInto([min, max]),
+    (n) => decimalPlaces ? round(n, decimalPlaces) : n
+  );
+  return constrained;
+};
+var valueToText = (numericValue) => {
+  if (numericValue === null || numericValue === void 0) {
+    return ``;
+  }
+  return numericValue.toString();
+};
+var NumberInput = ({
+  autoSize = false,
+  customCss,
+  decimalPlaces,
+  disabled = false,
+  label,
+  max,
+  min,
+  name,
+  onChange,
+  onClick,
+  placeholder = ``,
+  set = () => null,
+  testId,
+  value = null
+}) => {
+  const id = (0, import_react2.useId)();
+  const [temporaryEntry, setTemporaryEntry] = (0, import_react2.useState)(null);
+  const userHasMadeDeliberateChange = (0, import_react2.useRef)(false);
+  const refine = initRefinery({ max, min, decimalPlaces, nullable: true });
+  const allowDecimal = decimalPlaces === void 0 || decimalPlaces > 0;
+  const handleBlur = () => {
+    if (userHasMadeDeliberateChange.current) {
+      set(refine(value != null ? value : null));
+      setTemporaryEntry(null);
+    }
+    userHasMadeDeliberateChange.current = false;
+  };
+  const handleChange = (event) => {
+    var _a2;
+    if (onChange)
+      onChange(event);
+    if (set === void 0)
+      return;
+    userHasMadeDeliberateChange.current = true;
+    const input = event.target.value;
+    if (isValidNonNumber(input) || isDecimalInProgress(input)) {
+      setTemporaryEntry(input);
+      const textInterpretation = isDecimalInProgress(input) ? input : (_a2 = min == null ? void 0 : min.toString()) != null ? _a2 : `0`;
+      const newValue = textToValue(textInterpretation, allowDecimal);
+      set(refine(newValue));
+      return;
+    }
+    setTemporaryEntry(null);
+    const inputIsNumeric = !isNaN(Number(input)) && !input.includes(` `) || allowDecimal && input === `.` || allowDecimal && input === `-.` || input === `` || input === `-`;
+    const numericValue = textToValue(input, allowDecimal);
+    if (inputIsNumeric) {
+      set(refine(numericValue));
+    }
+  };
+  const displayValue = temporaryEntry != null ? temporaryEntry : valueToText(value ? refine(value) : value);
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { css: customCss, children: [
+    label && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("label", { htmlFor: id, children: label }),
+    autoSize ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      ElasticInput,
+      {
+        type: "text",
+        value: displayValue,
+        placeholder: placeholder != null ? placeholder : `-`,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        disabled,
+        name: name != null ? name : id,
+        id,
+        onClick,
+        "data-testid": `number-input-${testId != null ? testId : id}`
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "input",
+      {
+        type: "text",
+        value: displayValue,
+        placeholder: placeholder != null ? placeholder : `-`,
+        onChange: handleChange,
+        onBlur: handleBlur,
+        disabled,
+        name: name != null ? name : id,
+        id,
+        onClick,
+        "data-testid": `number-input-${testId != null ? testId : id}`
+      }
+    )
+  ] });
+};
+
+// ../../hamr/src/react-elastic-input/TextInput.tsx
+var import_jsx_runtime3 = require("@emotion/react/jsx-runtime");
+var TextInput = ({
+  value,
+  set,
+  label,
+  placeholder,
+  customCss,
+  autoSize = false
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { css: customCss, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("label", { children: label }),
+    autoSize ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      ElasticInput,
+      {
+        type: "text",
+        value,
+        onChange: (e) => set == null ? void 0 : set(e.target.value),
+        disabled: set === void 0,
+        placeholder
+      }
+    ) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "input",
+      {
+        type: "text",
+        value,
+        onChange: (e) => set == null ? void 0 : set(e.target.value),
+        disabled: set === void 0,
+        placeholder
+      }
+    )
+  ] });
+};
+
+// ../../hamr/src/react-json-editor/editors-by-type/utilities/array-elements.ts
+var makeElementSetters = (data, set) => data.map(
+  (value, index) => (newValue) => set(() => {
+    const newData = [...data];
+    newData[index] = become(newValue)(value);
+    return newData;
+  })
+);
+
+// ../../hamr/src/react-json-editor/json-editor-internal.tsx
+var import_jsx_runtime4 = require("@emotion/react/jsx-runtime");
+var JsonEditor_INTERNAL = ({
+  data,
+  set,
+  schema,
+  name,
+  rename,
+  remove,
+  recast,
+  path = [],
+  isReadonly = () => false,
+  isHidden = () => false,
+  className,
+  customCss,
+  Header: HeaderDisplay,
+  Components
+}) => {
+  const json = refineJsonType(data);
+  const SubEditor = SubEditors[json.type];
+  const disabled = isReadonly(path);
+  return isHidden(path) ? null : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Components.ErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(Components.EditorWrapper, { className, customCss, children: [
+    remove && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      Components.Button,
+      {
+        onClick: disabled ? doNothing : remove,
+        disabled,
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Components.DeleteIcon, {})
+      }
+    ),
+    HeaderDisplay && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(HeaderDisplay, { data, schema }),
+    rename && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Components.KeyWrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      ElasticInput,
+      {
+        value: name,
+        onChange: disabled ? doNothing : (e) => rename(e.target.value),
+        disabled
+      }
+    ) }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      SubEditor,
+      {
+        data: json.data,
+        set,
+        schema,
+        remove,
+        rename,
+        path,
+        isReadonly,
+        isHidden,
+        Components
+      }
+    ),
+    recast && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "select",
+      {
+        onChange: disabled ? doNothing : (e) => recast(e.target.value),
+        value: json.type,
+        disabled,
+        children: Object.keys(SubEditors).map((type) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("option", { value: type, children: type }, type))
+      }
+    )
+  ] }) });
+};
+
+// ../../hamr/src/react-json-editor/editors-by-type/array-editor.tsx
+var import_jsx_runtime5 = require("@emotion/react/jsx-runtime");
+var ArrayEditor = ({
+  path = [],
+  isReadonly = () => false,
+  isHidden = () => false,
+  data,
+  set,
+  Components
+}) => {
+  const setElement = makeElementSetters(data, set);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: data.map((element, index) => {
+    const newPath = [...path, index];
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      JsonEditor_INTERNAL,
+      {
+        path: newPath,
+        isReadonly,
+        isHidden,
+        data: element,
+        set: setElement[index],
+        Components
+      },
+      newPath.join(``)
+    );
+  }) });
+};
+
+// ../../hamr/src/react-json-editor/editors-by-type/object-editor.tsx
+var import_react3 = require("react");
+
+// ../../anvl/src/json-schema/json-schema.ts
+var import_boolean2 = require("fp-ts/boolean");
+var import_number3 = require("fp-ts/number");
+var import_string4 = require("fp-ts/string");
+
+// ../../anvl/src/json-schema/integer.ts
+var import_function10 = require("fp-ts/function");
+var isInteger = (input) => Number.isInteger(input);
+var parseInt = (input) => {
+  if (isInteger(input))
+    return input;
+  throw new IntegerParseError(input);
+};
+var _a;
+var Fraction = class extends Number {
+  constructor(n, d) {
+    super(n / d);
+    this[_a] = () => this.numerator / this.denominator;
+    if (d === 0) {
+      throw new Error(`Denominator cannot be zero`);
+    }
+    this.numerator = parseInt(n);
+    this.denominator = parseInt(d);
+  }
+};
+_a = Symbol.toPrimitive;
+var IntegerParseError = class extends Error {
+  constructor(value) {
+    super(`Could not parse integer from ${JSON.stringify(value)}`);
+  }
+};
+var Int = Object.assign((input) => parseInt(input), {
+  from: (input) => (0, import_function10.pipe)(
+    input,
+    String,
+    parseFloat,
+    (num) => isInteger(num) ? {
+      value: num,
+      error: null,
+      round: null,
+      upper: null,
+      lower: null,
+      ratio: null
+    } : {
+      value: null,
+      error: new IntegerParseError(input),
+      round: Math.round(num),
+      upper: Math.ceil(num),
+      lower: Math.floor(num),
+      ratio: null
+    }
+  ),
+  formula: (fm) => {
+    return (input) => {
+      return fm(
+        input
+      );
+    };
+  }
+});
+function asNumber(input) {
+  return input;
+}
+var a = asNumber(new Fraction(1, 2));
+var b = asNumber([new Fraction(1, 2)]);
+var c = asNumber({ a: new Fraction(1, 2) });
+
+// ../../anvl/src/json-schema/refs.ts
+var import_string2 = require("fp-ts/string");
+function isJsonSchemaRef(input) {
+  return doesExtend({
+    $ref: import_string2.isString
+  })(input);
+}
+var colorPalette = {
+  $defs: {
+    colorChannel: {
+      type: `integer`,
+      minimum: Int(0),
+      maximum: Int(255)
+    },
+    color: {
+      type: `object`,
+      properties: {
+        red: { $ref: `#/$defs/colorChannel` },
+        green: { $ref: `#/$defs/colorChannel` },
+        blue: { $ref: `#/$defs/colorChannel` }
+      }
+    }
+  },
+  type: `array`,
+  items: {
+    $ref: `#/$defs/color`
+  }
+};
+var retrieveRef = ({
+  refNode: { $ref },
+  refMap = {},
+  root
+}) => {
+  if (typeof root === `boolean`) {
+    throw new TypeError(`The root is a boolean and cannot be indexed`);
+  }
+  if ($ref in refMap)
+    return { node: refMap[$ref], refMap };
+  const [_, ...refPath] = $ref.split(`/`);
+  const discovery = delve(root, refPath);
+  if (discovery instanceof Error)
+    throw discovery;
+  let node = discovery.found;
+  while (isJsonSchemaRef(node)) {
+    const result = retrieveRef({ refNode: node, refMap, root });
+    node = result.node;
+    refMap = result.refMap;
+  }
+  if (isJsonSchema(node)) {
+    return { node, refMap: __spreadProps(__spreadValues({}, refMap), { [$ref]: node }) };
+  }
+  throw new TypeError(`The refNode is not a JsonSchema`);
+};
+
+// ../../anvl/src/json-schema/string-formats.ts
+var import_string3 = require("fp-ts/string");
+var JSON_SCHEMA_STRING_FORMATS = [
+  `date-time`,
+  `date`,
+  `email`,
+  `hostname`,
+  `ipv4`,
+  `ipv6`,
+  `regex`,
+  `time`,
+  `uri-reference`,
+  `uri-template`,
+  `uri`,
+  `uuid`
+];
+
+// ../../anvl/src/refinement/index.ts
+var canExist = (_) => true;
+var cannotExist = (_) => false;
+var isLiteral = (value) => (input) => input === value;
+var isWithin = (args) => (input) => args.includes(input);
+var couldBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r.name || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => {
+        var _a2;
+        return logging && console.log(
+          refinements.map((r) => r.name || `anon`).join(` | `),
+          `>`,
+          (_a2 = refinement.name) != null ? _a2 : `anon`,
+          `:`,
+          refinement(input)
+        ), refinement(input);
+      }
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => couldBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isUnion = couldBe(cannotExist);
+var mustBe = (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) => mustBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isIntersection = mustBe(canExist);
+
+// ../../anvl/src/json-schema/json-schema.ts
+var JSON_SCHEMA_TYPE_NAMES = [...JSON_TYPE_NAMES, `integer`];
+var JSON_SCHEMA_META_TYPE_NAMES = [
+  ...JSON_SCHEMA_TYPE_NAMES,
+  `any`,
+  `never`
+];
+var JSON_SCHEMA_REFINERY = {
+  array: isArraySchema,
+  boolean: isBooleanSchema,
+  integer: isIntegerSchema,
+  null: isNullSchema,
+  number: isNumberSchema,
+  object: isObjectSchema,
+  string: isStringSchema,
+  any: isLiteral(true),
+  never: isLiteral(false),
+  union: isUnionSchema,
+  intersection: isIntersectionSchema,
+  negation: isNegationSchema,
+  conditional: isConditionalSchema
+};
+var stringSchemaStructure = {
+  type: isLiteral(`string`),
+  enum: ifDefined(isArray(import_string4.isString)),
+  minLength: ifDefined(isInteger),
+  maxLength: ifDefined(isInteger),
+  pattern: ifDefined(import_string4.isString),
+  format: ifDefined(isWithin(JSON_SCHEMA_STRING_FORMATS))
+};
+function isStringSchema(input) {
+  return doesExtend(stringSchemaStructure)(input);
+}
+var numberSchemaStructure = {
+  type: isLiteral(`number`),
+  enum: ifDefined(isArray(import_number3.isNumber)),
+  minimum: ifDefined(import_number3.isNumber),
+  maximum: ifDefined(import_number3.isNumber),
+  exclusiveMinimum: ifDefined(import_number3.isNumber),
+  exclusiveMaximum: ifDefined(import_number3.isNumber),
+  multipleOf: ifDefined(import_number3.isNumber)
+};
+function isNumberSchema(input) {
+  return doesExtend(numberSchemaStructure)(input);
+}
+var integerSchemaStructure = {
+  type: isLiteral(`integer`),
+  enum: ifDefined(isArray(isInteger)),
+  minimum: ifDefined(isInteger),
+  maximum: ifDefined(isInteger),
+  exclusiveMinimum: ifDefined(isInteger),
+  exclusiveMaximum: ifDefined(isInteger),
+  multipleOf: ifDefined(isInteger)
+};
+function isIntegerSchema(input) {
+  return doesExtend(integerSchemaStructure)(input);
+}
+var booleanSchemaStructure = {
+  type: isLiteral(`boolean`),
+  enum: ifDefined(isArray(import_boolean2.isBoolean))
+};
+function isBooleanSchema(input) {
+  return doesExtend(booleanSchemaStructure)(input);
+}
+var nullSchemaStructure = {
+  type: isLiteral(`null`)
+};
+function isNullSchema(input) {
+  return doesExtend(nullSchemaStructure)(input);
+}
+var objectSchemaStructure = {
+  type: isLiteral(`object`),
+  properties: ifDefined(isRecord(import_string4.isString, isJsonSchema)),
+  required: ifDefined(isArray(import_string4.isString)),
+  additionalProperties: ifDefined(isJsonSchema),
+  propertyNames: ifDefined(isStringSchema),
+  minProperties: ifDefined(isInteger),
+  maxProperties: ifDefined(isInteger),
+  dependentSchemas: ifDefined(isRecord(import_string4.isString, isJsonSchema))
+};
+function isObjectSchema(input) {
+  return doesExtend(objectSchemaStructure)(input);
+}
+var arraySchemaStructure = {
+  type: isLiteral(`array`),
+  items: ifDefined(couldBe(isJsonSchema).or(isArray(isJsonSchema))),
+  minItems: ifDefined(isInteger),
+  maxItems: ifDefined(isInteger),
+  uniqueItems: ifDefined(import_boolean2.isBoolean)
+};
+function isArraySchema(input) {
+  return doesExtend(arraySchemaStructure)(input);
+}
+var unionSchemaStructure = { anyOf: isArray(isJsonSchema) };
+function isUnionSchema(input) {
+  return doesExtend(unionSchemaStructure)(input);
+}
+var exclusiveSchemaStructure = { oneOf: isArray(isJsonSchema) };
+function isExclusiveSchema(input) {
+  return doesExtend(exclusiveSchemaStructure)(input);
+}
+var intersectionSchemaStructure = { allOf: isArray(isJsonSchema) };
+function isIntersectionSchema(input) {
+  return doesExtend(intersectionSchemaStructure)(input);
+}
+var conditionalSchemaStructure = {
+  if: isJsonSchema,
+  then: ifDefined(isJsonSchema),
+  else: ifDefined(isJsonSchema)
+};
+function isConditionalSchema(input) {
+  return doesExtend(conditionalSchemaStructure)(input);
+}
+var negationSchemaStructure = { not: isJsonSchema };
+function isNegationSchema(input) {
+  return doesExtend(negationSchemaStructure)(input);
+}
+var mixedSchemaStructure = __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, arraySchemaStructure), booleanSchemaStructure), integerSchemaStructure), nullSchemaStructure), numberSchemaStructure), objectSchemaStructure), stringSchemaStructure), {
+  type: isArray(isWithin(JSON_SCHEMA_TYPE_NAMES)),
+  enum: ifDefined(
+    isArray(isUnion.or(isInteger).or(import_boolean2.isBoolean).or(import_number3.isNumber).or(import_string4.isString))
+  )
+});
+function isMixedSchema(input) {
+  return doesExtend(mixedSchemaStructure)(input);
+}
+var isJsonSchemaCore = isUnion.or(isArraySchema).or(isBooleanSchema).or(isConditionalSchema).or(isExclusiveSchema).or(isIntegerSchema).or(isIntersectionSchema).or(isMixedSchema).or(isNegationSchema).or(isNullSchema).or(isNumberSchema).or(isObjectSchema).or(isStringSchema).or(isUnionSchema);
+var isJsonSchemaRoot = doesExtend({
+  $id: ifDefined(import_string4.isString),
+  $schema: ifDefined(import_string4.isString)
+});
+var isJsonSchemaObject = isIntersection.and(isJsonSchemaCore).and(isJsonSchemaRoot);
+function isJsonSchema(input) {
+  return couldBe(isJsonSchemaObject).or(import_boolean2.isBoolean).or(isJsonSchemaRef)(input);
+}
+
+// ../../anvl/src/json-schema/path-into.ts
+var expandPathForSchema = (path) => {
+  try {
+    return path.map((key) => {
+      switch (typeof key) {
+        case `string`:
+          return [`properties`, key];
+        case `number`:
+          return [`items`, key];
+        case `symbol`:
+          throw new TypeError(
+            `The key ${String(
+              key
+            )} is not a valid JSON key; expected string or number, got symbol`
+          );
+        default:
+          throw new TypeError(
+            `The key ${key} is not a valid JSON key; expected string or number, got ${typeof key}`
+          );
+      }
+    }).flat();
+  } catch (caught) {
+    if (caught instanceof TypeError)
+      return caught;
+    throw caught;
+  }
+};
+
+// ../../anvl/src/json-schema/find-sub-schema.ts
+var findSubSchema = (schema) => {
+  if (typeof schema === `boolean`) {
+    throw new Error(`The schema does not contain subSchemas`);
+  }
+  return (path) => {
+    const pathIntoSchema = expandPathForSchema(path);
+    if (pathIntoSchema instanceof Error)
+      return pathIntoSchema;
+    if (typeof schema === `boolean`) {
+      return new TypeError(`The schema is not a JsonSchema`);
+    }
+    const { node, refMap } = pathIntoSchema.reduce(
+      ({ node: node2, refMap: refMap2 = void 0 }, key) => (console.log({ node: node2, key }), isJsonSchemaRef(node2) ? retrieveRef({ refNode: node2, root: schema, refMap: refMap2 }) : { node: node2[key], refMap: refMap2 }),
+      { node: schema, refMap: void 0 }
+    );
+    if (node instanceof Error)
+      throw node;
+    let subSchema = node;
+    while (isJsonSchemaRef(subSchema)) {
+      console.log({ subSchema });
+      subSchema = retrieveRef({ refNode: subSchema, root: schema, refMap }).node;
+    }
+    console.log({ subSchema });
+    if (isJsonSchema(subSchema)) {
+      return subSchema;
+    }
+    throw new TypeError(`The subSchema is not a JsonSchema`);
+  };
+};
+
+// ../../anvl/src/json/cast.ts
+var stringToBoolean = (str) => str === `true`;
+var stringToNumber = (str) => Number(str);
+var stringToArray = (str) => str.split(`,`);
+var stringToObject = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return { [str]: str };
+  }
+};
+var objectToString = (obj) => JSON.stringify(obj);
+var objectToBoolean = (obj) => obj.true === true;
+var objectToNumber = (obj) => {
+  var _a2, _b, _c;
+  return Number((_c = (_b = (_a2 = obj.number) != null ? _a2 : obj.size) != null ? _b : obj.count) != null ? _c : 0);
+};
+var objectToArray = (obj) => Object.entries(obj);
+var booleanToString = (bool) => bool.toString();
+var booleanToNumber = (bool) => +bool;
+var booleanToObject = (bool) => ({
+  [bool.toString()]: bool
+});
+var booleanToArray = (bool) => [bool];
+var numberToString = (num) => num.toString();
+var numberToBoolean = (num) => num === 1;
+var numberToObject = (num) => ({
+  number: num
+});
+var numberToArray = (num) => Array(num).fill(null);
+var arrayToString = (arr) => arr.join(`,`);
+var arrayToNumber = (arr) => arr.length;
+var arrayToBoolean = (arr) => typeof arr[0] === `boolean` ? arr[0] : arr.length > 0;
+var arrayToObject = (arr) => arr.reduce((acc, cur, idx) => {
+  acc[`${idx}`] = cur;
+  return acc;
+}, {});
+var nullToString = () => ``;
+var nullToNumber = () => 0;
+var nullToBoolean = () => false;
+var nullToArray = () => [];
+var nullToObject = () => ({});
+var cast = (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();
+        }
+      },
+      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();
+        }
+      },
+      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();
+        }
+      },
+      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();
+        }
+      },
+      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();
+        }
+      },
+      null: () => null
+    }
+  };
+};
+
+// ../../Luum/src/utils/mapObject.ts
+var mapObject2 = (obj, fn) => {
+  const newObj = {};
+  const entries = Object.entries(obj);
+  entries.forEach(([key, val]) => newObj[key] = fn(val, key));
+  return newObj;
+};
+var mapObject_default = mapObject2;
+
+// ../../hamr/src/react-json-editor/editors-by-type/utilities/object-properties.ts
+var makePropertySetters = (data, set) => mapObject_default(
+  data,
+  (value, key) => (newValue) => set(__spreadProps(__spreadValues({}, data), { [key]: become(newValue)(value[key]) }))
+);
+var makePropertyRenamers = (data, set, stableKeyMapRef) => mapObject_default(
+  data,
+  (value, key) => (newKey) => Object.hasOwn(data, newKey) ? null : set(() => {
+    const entries = Object.entries(data);
+    const index = entries.findIndex(([k]) => k === key);
+    entries[index] = [newKey, value];
+    const stableKeyMap = stableKeyMapRef.current;
+    stableKeyMapRef.current = __spreadProps(__spreadValues({}, stableKeyMap), {
+      [newKey]: stableKeyMap[key]
+    });
+    return Object.fromEntries(entries);
+  })
+);
+var makePropertyRemovers = (data, set) => mapObject_default(
+  data,
+  (_, key) => () => set(() => {
+    const _a2 = data, { [key]: _2 } = _a2, rest = __objRest(_a2, [__restKey(key)]);
+    return rest;
+  })
+);
+var makePropertyRecasters = (data, set) => mapObject_default(
+  data,
+  (value, key) => (newType) => set(() => __spreadProps(__spreadValues({}, data), {
+    [key]: cast(value).to[newType]()
+  }))
+);
+var makePropertyCreationInterface = (data, set) => (key, type) => (value) => set(__spreadProps(__spreadValues({}, data), { [key]: value != null ? value : JSON_DEFAULTS[type] }));
+var makePropertySorter = (data, set, sortFn) => () => {
+  const sortedKeys = Object.keys(data).sort(sortFn);
+  const sortedObj = {};
+  sortedKeys.forEach((key) => sortedObj[key] = data[key]);
+  set(sortedObj);
+};
+
+// ../../hamr/src/react-json-editor/editors-by-type/object-editor.tsx
+var import_jsx_runtime6 = require("@emotion/react/jsx-runtime");
+var PropertyAdder = ({
+  addProperty,
+  disabled,
+  propertyKey,
+  Components
+}) => /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(Components.MissingPropertyWrapper, { children: [
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ElasticInput, { disabled: true, defaultValue: propertyKey }),
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ElasticInput, { disabled: true, defaultValue: "is missing" }),
+  /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Components.Button, { onClick: () => addProperty(), disabled, children: "+" })
+] });
+var ObjectEditor = ({
+  schema,
+  path = [],
+  isReadonly = () => false,
+  isHidden = () => false,
+  data,
+  set,
+  Components
+}) => {
+  var _a2;
+  const disabled = isReadonly(path);
+  const stableKeyMap = (0, import_react3.useRef)(
+    Object.keys(data).reduce((acc, key) => {
+      acc[key] = key;
+      return acc;
+    }, {})
+  );
+  const setProperty = makePropertySetters(data, set);
+  const renameProperty = makePropertyRenamers(data, set, stableKeyMap);
+  const removeProperty = makePropertyRemovers(data, set);
+  const recastProperty = makePropertyRecasters(data, set);
+  const sortProperties = makePropertySorter(data, set);
+  const makePropertyAdder = makePropertyCreationInterface(data, set);
+  const subSchema = isPlainObject(schema) ? findSubSchema(schema)(path) : true;
+  const schemaKeys = isLiteral(true)(subSchema) ? true : isObjectSchema(subSchema) ? Object.keys((_a2 = subSchema.properties) != null ? _a2 : {}) : [];
+  const dataKeys = Object.keys(data);
+  const [unofficialKeys, officialKeys] = dataKeys.reduce(
+    ([unofficial, official], key) => {
+      const isOfficial = schemaKeys === true || schemaKeys.includes(key);
+      return isOfficial ? [unofficial, [...official, key]] : [[...unofficial, key], official];
+    },
+    [[], []]
+  );
+  const missingKeys = schemaKeys === true ? [] : schemaKeys.filter((key) => !dataKeys.includes(key));
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Components.Button, { onClick: () => sortProperties(), disabled, children: "Sort" }),
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(Components.ObjectWrapper, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: "json_editor_properties", children: [...missingKeys, ...officialKeys, ...unofficialKeys].map((key) => {
+        const originalKey = stableKeyMap.current[key];
+        const newPath = [...path, key];
+        const originalPath = [...path, originalKey];
+        const isOfficial = schemaKeys === true || schemaKeys.includes(key);
+        const isMissing = missingKeys.includes(key);
+        return isMissing ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          PropertyAdder,
+          {
+            propertyKey: key,
+            addProperty: makePropertyAdder(key, `string`),
+            disabled,
+            Components
+          },
+          key + `IsMissing`
+        ) : /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+          JsonEditor_INTERNAL,
+          {
+            schema,
+            path: newPath,
+            name: key,
+            isReadonly,
+            isHidden,
+            data: data[key],
+            set: setProperty[key],
+            rename: renameProperty[key],
+            remove: removeProperty[key],
+            recast: recastProperty[key],
+            className: `json_editor_property ${isOfficial ? `json_editor_official` : `json_editor_unofficial`}`,
+            Components
+          },
+          originalPath.join(`.`)
+        );
+      }) }),
+      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+        Components.Button,
+        {
+          onClick: disabled ? doNothing : () => makePropertyAdder(`new_property`, `string`)(),
+          disabled,
+          children: "+"
+        }
+      )
+    ] })
+  ] });
+};
+
+// ../../hamr/src/react-json-editor/editors-by-type/primitive-editors.tsx
+var import_jsx_runtime7 = require("@emotion/react/jsx-runtime");
+var BooleanEditor = ({
+  data,
+  set
+}) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+  "input",
+  {
+    type: "checkbox",
+    checked: data,
+    onChange: (event) => set(event.target.checked)
+  }
+);
+var NullEditor = () => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("input", { type: "text", value: "null", readOnly: true });
+var NumberEditor = ({
+  path = [],
+  isReadonly = () => false,
+  data,
+  set
+}) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+  NumberInput,
+  {
+    value: data,
+    set: isReadonly(path) ? void 0 : (newValue) => set(Number(newValue)),
+    autoSize: true
+  }
+);
+var StringEditor = ({
+  path = [],
+  isReadonly = () => false,
+  data,
+  set,
+  Components
+}) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Components.StringWrapper, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    TextInput,
+    {
+      value: data,
+      set: isReadonly(path) ? void 0 : set,
+      autoSize: true
+    }
+  ) });
+};
+
+// ../../hamr/src/react-error-boundary/ErrorBoundary.tsx
+var import_react4 = require("react");
+var import_recoil = require("recoil");
+
+// ../../hamr/src/react-error-boundary/DefaultFallback.tsx
+var import_jsx_runtime8 = require("@emotion/react/jsx-runtime");
+var DefaultFallback = ({ error, errorInfo }) => {
+  var _a2, _b;
+  const component = errorInfo == null ? void 0 : errorInfo.componentStack.split(` `).filter(Boolean)[2];
+  const message = (_b = (_a2 = error == null ? void 0 : error.toString()) != null ? _a2 : errorInfo == null ? void 0 : errorInfo.componentStack) != null ? _b : `Unknown error`;
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    "div",
+    {
+      "data-testid": "error-boundary",
+      style: {
+        flex: `1`,
+        background: `black`,
+        backgroundImage: `url(./src/assets/kablooey.gif)`,
+        backgroundPosition: `center`,
+        // backgroundRepeat: `no-repeat`,
+        backgroundSize: `overlay`
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+        "div",
+        {
+          style: {
+            margin: `50px`,
+            marginTop: `0`,
+            padding: `50px`,
+            border: `1px solid dashed`
+          },
+          children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(
+            "span",
+            {
+              style: {
+                background: `black`,
+                color: `white`,
+                padding: 10,
+                paddingTop: 5
+              },
+              children: [
+                `\u26A0\uFE0F `,
+                /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("span", { style: { color: `#fc0`, fontWeight: 700 }, children: component }),
+                ` \u26A0\uFE0F `,
+                message
+              ]
+            }
+          )
+        }
+      )
+    }
+  );
+};
+
+// ../../hamr/src/react-error-boundary/ErrorBoundary.tsx
+var import_jsx_runtime9 = require("@emotion/react/jsx-runtime");
+var ErrorBoundary = class extends import_react4.Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: void 0, errorInfo: void 0 };
+  }
+  componentDidCatch(error, errorInfo) {
+    var _a2, _b;
+    (_b = (_a2 = this.props).onError) == null ? void 0 : _b.call(_a2, error, errorInfo);
+    this.setState({
+      error,
+      errorInfo
+    });
+  }
+  render() {
+    const { error, errorInfo } = this.state;
+    const { children, Fallback = DefaultFallback } = this.props;
+    return errorInfo ? /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Fallback, { error, errorInfo }) : children;
+  }
+};
+var findErrorBoundaryState = (0, import_recoil.atomFamily)({
+  key: `errorBoundary`,
+  default: { error: void 0, errorInfo: void 0 }
+});
+
+// ../../hamr/src/react-json-editor/default-components.tsx
+var import_jsx_runtime10 = require("@emotion/react/jsx-runtime");
+var DEFAULT_JSON_EDITOR_COMPONENTS = {
+  ErrorBoundary: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(ErrorBoundary, { children }),
+  Button: ({ onClick, children, disabled }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("button", { className: "json_editor_button", onClick, disabled, children }),
+  EditorWrapper: ({ children, customCss, className }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: `json_editor ` + className, css: customCss, children }),
+  EditorLayout: ({
+    DeleteButton,
+    Header,
+    KeyInput,
+    TypeSelect,
+    ValueEditor,
+    Wrapper
+  }) => {
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(Wrapper, { children: [
+      DeleteButton && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DeleteButton, {}),
+      Header && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Header, {}),
+      KeyInput && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(KeyInput, {}),
+      TypeSelect && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(TypeSelect, {}),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(ValueEditor, {})
+    ] });
+  },
+  ArrayWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "json_editor_array", children }),
+  ObjectWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "json_editor_object", children }),
+  StringWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_string", children }),
+  NumberWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_number", children }),
+  BooleanWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_boolean", children }),
+  NullWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_null", children }),
+  MissingPropertyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "json_editor_property json_editor_missing", children }),
+  MiscastPropertyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("div", { className: "json_editor_property json_editor_miscast", children }),
+  IllegalPropertyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_property json_editor_illegal", children }),
+  OfficialPropertyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_property json_editor_official", children }),
+  UnofficialPropertyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_property json_editor_unofficial", children }),
+  DeleteIcon: () => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_icon json_editor_delete", children: "x" }),
+  KeyWrapper: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("span", { className: "json_editor_key", children })
+};
+
+// ../../hamr/src/react-json-editor/developer-interface.tsx
+var import_react5 = require("react");
+var import_ajv = __toESM(require("ajv"));
+var import_jsx_runtime11 = require("@emotion/react/jsx-runtime");
+var JsonEditor = ({
+  data,
+  set,
+  schema = true,
+  name,
+  rename,
+  remove,
+  isReadonly = () => false,
+  isHidden = () => false,
+  // isIllegal = () => false,
+  className,
+  customCss,
+  Header,
+  Components: CustomComponents = {}
+}) => {
+  const Components = __spreadValues(__spreadValues({}, DEFAULT_JSON_EDITOR_COMPONENTS), CustomComponents);
+  const ajv = new import_ajv.default({ allErrors: true, verbose: true });
+  const validate = (0, import_react5.useMemo)(() => {
+    return ajv.compile(schema);
+  }, [schema]);
+  const validationResults = validate(data);
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    JsonEditor_INTERNAL,
+    {
+      data,
+      set,
+      name,
+      schema,
+      rename,
+      remove,
+      path: [],
+      isReadonly,
+      isHidden,
+      className,
+      customCss,
+      Header,
+      Components
+    }
+  );
+};
+
+// ../../hamr/src/react-json-editor/index.ts
+var SubEditors = {
+  array: ArrayEditor,
+  boolean: BooleanEditor,
+  null: NullEditor,
+  number: NumberEditor,
+  object: ObjectEditor,
+  string: StringEditor
+};
+
+// ../src/react-devtools/StateEditor.tsx
+var import_jsx_runtime12 = require("@emotion/react/jsx-runtime");
+var StateEditor = ({ storeHooks, token }) => {
+  const [data, set] = storeHooks.useIO(token);
+  return isPlainJson(data) ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(JsonEditor, { data, set, schema: true }) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "json_editor", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    ElasticInput,
+    {
+      value: data instanceof Set ? `Set { ${JSON.stringify([...data]).slice(1, -1)} }` : data instanceof Map ? `Map ` + JSON.stringify([...data]) : Object.getPrototypeOf(data).constructor.name + ` ` + JSON.stringify(data),
+      disabled: true
+    }
+  ) });
+};
+var ReadonlySelectorEditor = ({ storeHooks, token }) => {
+  const data = storeHooks.useO(token);
+  return isPlainJson(data) ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    JsonEditor,
+    {
+      data,
+      set: () => null,
+      schema: true,
+      isReadonly: () => true
+    }
+  ) : /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("div", { className: "json_editor", children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+    ElasticInput,
+    {
+      value: data instanceof Set ? `Set ` + JSON.stringify([...data]) : data instanceof Map ? `Map ` + JSON.stringify([...data]) : Object.getPrototypeOf(data).constructor.name + ` ` + JSON.stringify(data),
+      disabled: true
+    }
+  ) });
+};
+var StoreEditor = ({ storeHooks, token }) => {
+  if (token.type === `readonly_selector`) {
+    return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(ReadonlySelectorEditor, { storeHooks, token });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(StateEditor, { storeHooks, token });
+};
+
+// ../src/react-devtools/TokenList.tsx
+var import_jsx_runtime13 = require("@emotion/react/jsx-runtime");
+var TokenList = ({ storeHooks, tokenIndex }) => {
+  const tokenIds = storeHooks.useO(tokenIndex);
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_jsx_runtime13.Fragment, { children: Object.entries(tokenIds).map(([key, token]) => /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_react6.Fragment, { children: key.startsWith(`\u{1F441}\u200D\u{1F5E8}_`) ? null : /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "node", children: [
+    key,
+    ":",
+    `type` in token ? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(StoreEditor, { storeHooks, token }) : recordToEntries(token.familyMembers).map(([key2, token2]) => /* @__PURE__ */ (0, import_jsx_runtime13.jsxs)("div", { className: "node", children: [
+      key2,
+      ":",
+      /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(StoreEditor, { storeHooks, token: token2 })
+    ] }, key2))
+  ] }) }, key)) });
+};
+
+// ../src/web-effects/storage.ts
+var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, onSet }) => {
+  const savedValue = storage.getItem(key);
+  if (savedValue != null)
+    setSelf(parse(savedValue));
+  onSet(({ newValue }) => {
+    if (newValue == null) {
+      storage.removeItem(key);
+      return;
+    }
+    storage.setItem(key, stringify(newValue));
+  });
+};
+var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
+
+// ../src/react-devtools/AtomIODevtools.tsx
+var import_jsx_runtime14 = require("@emotion/react/jsx-runtime");
+var { atomTokenIndexState, selectorTokenIndexState } = import_atom.__INTERNAL__.META.attachMetaState();
+var devtoolsAreOpenState = (0, import_atom.atom)({
+  key: `\u{1F441}\u200D\u{1F5E8}_devtools_are_open`,
+  default: true,
+  effects: [lazyLocalStorageEffect(`\u{1F441}\u200D\u{1F5E8}_devtools_are_open`)]
+});
+var composeDevtools = (storeHooks) => {
+  const Devtools = () => {
+    const constraintsRef = (0, import_react7.useRef)(null);
+    const [devtoolsAreOpen, setDevtoolsAreOpen] = storeHooks.useIO(devtoolsAreOpenState);
+    const mouseHasMoved = (0, import_react7.useRef)(false);
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+        import_framer_motion.motion.span,
+        {
+          ref: constraintsRef,
+          className: "atom_io_devtools_zone",
+          style: {
+            position: `fixed`,
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0,
+            pointerEvents: `none`
+          }
+        }
+      ),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(
+        import_framer_motion.motion.main,
+        {
+          drag: true,
+          dragConstraints: constraintsRef,
+          className: "atom_io_devtools",
+          transition: import_framer_motion.spring,
+          style: devtoolsAreOpen ? {} : {
+            backgroundColor: `#0000`,
+            borderColor: `#0000`,
+            maxHeight: 28,
+            maxWidth: 33
+          },
+          children: [
+            devtoolsAreOpen ? /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_framer_motion.motion.header, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("h1", { children: "atom.io" }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_framer_motion.motion.main, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_framer_motion.LayoutGroup, { children: [
+                /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("section", { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("h2", { children: "atoms" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+                    TokenList,
+                    {
+                      storeHooks,
+                      tokenIndex: atomTokenIndexState
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)("section", { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("h2", { children: "selectors" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+                    TokenList,
+                    {
+                      storeHooks,
+                      tokenIndex: selectorTokenIndexState
+                    }
+                  )
+                ] })
+              ] }) })
+            ] }) : null,
+            /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("footer", { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
+              "button",
+              {
+                onMouseDown: () => mouseHasMoved.current = false,
+                onMouseMove: () => mouseHasMoved.current = true,
+                onMouseUp: () => {
+                  if (!mouseHasMoved.current) {
+                    setDevtoolsAreOpen((open) => !open);
+                  }
+                },
+                children: "\u{1F441}\u200D\u{1F5E8}"
+              }
+            ) })
+          ]
+        }
+      )
+    ] });
+  };
+  return Devtools;
+};
+var AtomIODevtools = composeDevtools({ useI: import_react8.useI, useO: import_react8.useO, useIO: import_react8.useIO });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AtomIODevtools,
+  composeDevtools
+});
+//# sourceMappingURL=index.js.map