@tomorrowevening/theatric 1.0.8

package/dist/index.js

@@ -0,0 +1,1792 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+
+// src/index.ts
+__export(exports, {
+  button: () => button,
+  getAssetUrl: () => getAssetUrl,
+  initialize: () => initialize,
+  types: () => import_theatre_core3.types,
+  useControls: () => useControls
+});
+var import_theatre_core = __toModule(require("@tomorrowevening/theatre-core"));
+var import_theatre_core2 = __toModule(require("@tomorrowevening/theatre-core"));
+
+// ../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof window == "object" && window && window.Object === Object && window;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../../node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// ../../node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// ../../node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// ../../node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// ../../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// ../../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// ../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// ../../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// ../../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// ../../node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// ../../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// ../../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// ../../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// ../../node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// ../../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// ../../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// ../../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// ../../node_modules/lodash-es/_Map.js
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
+
+// ../../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// ../../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// ../../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// ../../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// ../../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// ../../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// ../../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// ../../node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// ../dataverse/src/pointer.ts
+var pointerMetaWeakMap = new WeakMap();
+var cachedSubPathPointersWeakMap = new WeakMap();
+var pointerMetaSymbol = Symbol("pointerMeta");
+var getPointerMeta = (p) => {
+  const meta = p[pointerMetaSymbol];
+  return meta;
+};
+var isPointer = (p) => {
+  return p && !!getPointerMeta(p);
+};
+
+// ../dataverse/src/utils/Stack.ts
+var Stack = class {
+  constructor() {
+    this._head = void 0;
+  }
+  peek() {
+    return this._head && this._head.data;
+  }
+  pop() {
+    const head = this._head;
+    if (!head) {
+      return void 0;
+    }
+    this._head = head.next;
+    return head.data;
+  }
+  push(data) {
+    const node = { next: this._head, data };
+    this._head = node;
+  }
+};
+
+// ../dataverse/src/prism/discoveryMechanism.ts
+function createMechanism() {
+  const noop = () => {
+  };
+  const stack = new Stack();
+  const noopCollector = noop;
+  const pushCollector2 = (collector) => {
+    stack.push(collector);
+  };
+  const popCollector2 = (collector) => {
+    const existing = stack.peek();
+    if (existing !== collector) {
+      throw new Error(`Popped collector is not on top of the stack`);
+    }
+    stack.pop();
+  };
+  const startIgnoringDependencies2 = () => {
+    stack.push(noopCollector);
+  };
+  const stopIgnoringDependencies2 = () => {
+    if (stack.peek() !== noopCollector) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("This should never happen");
+      }
+    } else {
+      stack.pop();
+    }
+  };
+  const reportResolutionStart2 = (d) => {
+    const possibleCollector = stack.peek();
+    if (possibleCollector) {
+      possibleCollector(d);
+    }
+    stack.push(noopCollector);
+  };
+  const reportResolutionEnd2 = (_d) => {
+    stack.pop();
+  };
+  return {
+    type: "Dataverse_discoveryMechanism",
+    startIgnoringDependencies: startIgnoringDependencies2,
+    stopIgnoringDependencies: stopIgnoringDependencies2,
+    reportResolutionStart: reportResolutionStart2,
+    reportResolutionEnd: reportResolutionEnd2,
+    pushCollector: pushCollector2,
+    popCollector: popCollector2
+  };
+}
+function getSharedMechanism() {
+  const varName = "__dataverse_discoveryMechanism_sharedStack";
+  const root2 = typeof window !== "undefined" ? window : typeof window !== "undefined" ? window : {};
+  if (root2) {
+    const existingMechanism = root2[varName];
+    if (existingMechanism && typeof existingMechanism === "object" && existingMechanism.type === "Dataverse_discoveryMechanism") {
+      return existingMechanism;
+    } else {
+      const mechanism = createMechanism();
+      root2[varName] = mechanism;
+      return mechanism;
+    }
+  } else {
+    return createMechanism();
+  }
+}
+var {
+  startIgnoringDependencies,
+  stopIgnoringDependencies,
+  reportResolutionEnd,
+  reportResolutionStart,
+  pushCollector,
+  popCollector
+} = getSharedMechanism();
+
+// ../dataverse/src/prism/prism.ts
+var voidFn = () => {
+};
+var HotHandle = class {
+  constructor(_fn, _prismInstance) {
+    this._fn = _fn;
+    this._prismInstance = _prismInstance;
+    this._didMarkDependentsAsStale = false;
+    this._isFresh = false;
+    this._cacheOfDendencyValues = new Map();
+    this._dependents = new Set();
+    this._dependencies = new Set();
+    this._possiblyStaleDeps = new Set();
+    this._scope = new HotScope(this);
+    this._lastValue = void 0;
+    this._forciblySetToStale = false;
+    this._reactToDependencyGoingStale = (which) => {
+      this._possiblyStaleDeps.add(which);
+      this._markAsStale();
+    };
+    for (const d of this._dependencies) {
+      d._addDependent(this._reactToDependencyGoingStale);
+    }
+    startIgnoringDependencies();
+    this.getValue();
+    stopIgnoringDependencies();
+  }
+  get hasDependents() {
+    return this._dependents.size > 0;
+  }
+  removeDependent(d) {
+    this._dependents.delete(d);
+  }
+  addDependent(d) {
+    this._dependents.add(d);
+  }
+  destroy() {
+    for (const d of this._dependencies) {
+      d._removeDependent(this._reactToDependencyGoingStale);
+    }
+    cleanupScopeStack(this._scope);
+  }
+  getValue() {
+    if (!this._isFresh) {
+      const newValue = this._recalculate();
+      this._lastValue = newValue;
+      this._isFresh = true;
+      this._didMarkDependentsAsStale = false;
+      this._forciblySetToStale = false;
+    }
+    return this._lastValue;
+  }
+  _recalculate() {
+    let value;
+    if (!this._forciblySetToStale) {
+      if (this._possiblyStaleDeps.size > 0) {
+        let anActuallyStaleDepWasFound = false;
+        startIgnoringDependencies();
+        for (const dep of this._possiblyStaleDeps) {
+          if (this._cacheOfDendencyValues.get(dep) !== dep.getValue()) {
+            anActuallyStaleDepWasFound = true;
+            break;
+          }
+        }
+        stopIgnoringDependencies();
+        this._possiblyStaleDeps.clear();
+        if (!anActuallyStaleDepWasFound) {
+          return this._lastValue;
+        }
+      }
+    }
+    const newDeps = new Set();
+    this._cacheOfDendencyValues.clear();
+    const collector = (observedDep) => {
+      newDeps.add(observedDep);
+      this._addDependency(observedDep);
+    };
+    pushCollector(collector);
+    hookScopeStack.push(this._scope);
+    try {
+      value = this._fn();
+    } catch (error) {
+      console.error(error);
+    } finally {
+      const topOfTheStack = hookScopeStack.pop();
+      if (topOfTheStack !== this._scope) {
+        console.warn(`The Prism hook stack has slipped. This is a bug.`);
+      }
+    }
+    popCollector(collector);
+    for (const dep of this._dependencies) {
+      if (!newDeps.has(dep)) {
+        this._removeDependency(dep);
+      }
+    }
+    this._dependencies = newDeps;
+    startIgnoringDependencies();
+    for (const dep of newDeps) {
+      this._cacheOfDendencyValues.set(dep, dep.getValue());
+    }
+    stopIgnoringDependencies();
+    return value;
+  }
+  forceStale() {
+    this._forciblySetToStale = true;
+    this._markAsStale();
+  }
+  _markAsStale() {
+    if (this._didMarkDependentsAsStale)
+      return;
+    this._didMarkDependentsAsStale = true;
+    this._isFresh = false;
+    for (const dependent of this._dependents) {
+      dependent(this._prismInstance);
+    }
+  }
+  _addDependency(d) {
+    if (this._dependencies.has(d))
+      return;
+    this._dependencies.add(d);
+    d._addDependent(this._reactToDependencyGoingStale);
+  }
+  _removeDependency(d) {
+    if (!this._dependencies.has(d))
+      return;
+    this._dependencies.delete(d);
+    d._removeDependent(this._reactToDependencyGoingStale);
+  }
+};
+var emptyObject = {};
+var PrismInstance = class {
+  constructor(_fn) {
+    this._fn = _fn;
+    this.isPrism = true;
+    this._state = {
+      hot: false,
+      handle: void 0
+    };
+  }
+  get isHot() {
+    return this._state.hot;
+  }
+  onChange(ticker, listener, immediate = false) {
+    const dependent = () => {
+      ticker.onThisOrNextTick(refresh);
+    };
+    let lastValue = emptyObject;
+    const refresh = () => {
+      const newValue = this.getValue();
+      if (newValue === lastValue)
+        return;
+      lastValue = newValue;
+      listener(newValue);
+    };
+    this._addDependent(dependent);
+    if (immediate) {
+      lastValue = this.getValue();
+      listener(lastValue);
+    }
+    const unsubscribe = () => {
+      this._removeDependent(dependent);
+      ticker.offThisOrNextTick(refresh);
+      ticker.offNextTick(refresh);
+    };
+    return unsubscribe;
+  }
+  onStale(callback) {
+    const untap = () => {
+      this._removeDependent(fn);
+    };
+    const fn = () => callback();
+    this._addDependent(fn);
+    return untap;
+  }
+  keepHot() {
+    return this.onStale(() => {
+    });
+  }
+  _addDependent(d) {
+    if (!this._state.hot) {
+      this._goHot();
+    }
+    this._state.handle.addDependent(d);
+  }
+  _goHot() {
+    const hotHandle = new HotHandle(this._fn, this);
+    this._state = {
+      hot: true,
+      handle: hotHandle
+    };
+  }
+  _removeDependent(d) {
+    const state2 = this._state;
+    if (!state2.hot) {
+      return;
+    }
+    const handle = state2.handle;
+    handle.removeDependent(d);
+    if (!handle.hasDependents) {
+      this._state = { hot: false, handle: void 0 };
+      handle.destroy();
+    }
+  }
+  getValue() {
+    reportResolutionStart(this);
+    const state2 = this._state;
+    let val3;
+    if (state2.hot) {
+      val3 = state2.handle.getValue();
+    } else {
+      val3 = calculateColdPrism(this._fn);
+    }
+    reportResolutionEnd(this);
+    return val3;
+  }
+};
+var HotScope = class {
+  constructor(_hotHandle) {
+    this._hotHandle = _hotHandle;
+    this._refs = new Map();
+    this.isPrismScope = true;
+    this.subs = {};
+    this.effects = new Map();
+    this.memos = new Map();
+  }
+  ref(key, initialValue) {
+    let ref2 = this._refs.get(key);
+    if (ref2 !== void 0) {
+      return ref2;
+    } else {
+      const ref3 = {
+        current: initialValue
+      };
+      this._refs.set(key, ref3);
+      return ref3;
+    }
+  }
+  effect(key, cb, deps) {
+    let effect2 = this.effects.get(key);
+    if (effect2 === void 0) {
+      effect2 = {
+        cleanup: voidFn,
+        deps: void 0
+      };
+      this.effects.set(key, effect2);
+    }
+    if (depsHaveChanged(effect2.deps, deps)) {
+      effect2.cleanup();
+      startIgnoringDependencies();
+      effect2.cleanup = safelyRun(cb, voidFn).value;
+      stopIgnoringDependencies();
+      effect2.deps = deps;
+    }
+  }
+  memo(key, fn, deps) {
+    let memo2 = this.memos.get(key);
+    if (memo2 === void 0) {
+      memo2 = {
+        cachedValue: null,
+        deps: void 0
+      };
+      this.memos.set(key, memo2);
+    }
+    if (depsHaveChanged(memo2.deps, deps)) {
+      startIgnoringDependencies();
+      memo2.cachedValue = safelyRun(fn, void 0).value;
+      stopIgnoringDependencies();
+      memo2.deps = deps;
+    }
+    return memo2.cachedValue;
+  }
+  state(key, initialValue) {
+    const { value, setValue } = this.memo("state/" + key, () => {
+      const value2 = { current: initialValue };
+      const setValue2 = (newValue) => {
+        value2.current = newValue;
+        this._hotHandle.forceStale();
+      };
+      return { value: value2, setValue: setValue2 };
+    }, []);
+    return [value.current, setValue];
+  }
+  sub(key) {
+    if (!this.subs[key]) {
+      this.subs[key] = new HotScope(this._hotHandle);
+    }
+    return this.subs[key];
+  }
+  cleanupEffects() {
+    for (const effect2 of this.effects.values()) {
+      safelyRun(effect2.cleanup, void 0);
+    }
+    this.effects.clear();
+  }
+  source(subscribe, getValue2) {
+    const sourceKey = "$$source/blah";
+    this.effect(sourceKey, () => {
+      const unsub = subscribe(() => {
+        this._hotHandle.forceStale();
+      });
+      return unsub;
+    }, [subscribe]);
+    return getValue2();
+  }
+};
+function cleanupScopeStack(scope2) {
+  for (const sub2 of Object.values(scope2.subs)) {
+    cleanupScopeStack(sub2);
+  }
+  scope2.cleanupEffects();
+}
+function safelyRun(fn, returnValueInCaseOfError) {
+  try {
+    return { value: fn(), ok: true };
+  } catch (error) {
+    setTimeout(function PrismReportThrow() {
+      throw error;
+    });
+    return { value: returnValueInCaseOfError, ok: false };
+  }
+}
+var hookScopeStack = new Stack();
+function ref(key, initialValue) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.ref() is called outside of a prism() call.`);
+  }
+  return scope2.ref(key, initialValue);
+}
+function effect(key, cb, deps) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.effect() is called outside of a prism() call.`);
+  }
+  return scope2.effect(key, cb, deps);
+}
+function depsHaveChanged(oldDeps, newDeps) {
+  if (oldDeps === void 0 || newDeps === void 0) {
+    return true;
+  }
+  const len = oldDeps.length;
+  if (len !== newDeps.length)
+    return true;
+  for (let i = 0; i < len; i++) {
+    if (oldDeps[i] !== newDeps[i])
+      return true;
+  }
+  return false;
+}
+function memo(key, fn, deps) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.memo() is called outside of a prism() call.`);
+  }
+  return scope2.memo(key, fn, deps);
+}
+function state(key, initialValue) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.state() is called outside of a prism() call.`);
+  }
+  return scope2.state(key, initialValue);
+}
+function ensurePrism() {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`The parent function is called outside of a prism() call.`);
+  }
+}
+function scope(key, fn) {
+  const parentScope = hookScopeStack.peek();
+  if (!parentScope) {
+    throw new Error(`prism.scope() is called outside of a prism() call.`);
+  }
+  const subScope = parentScope.sub(key);
+  hookScopeStack.push(subScope);
+  const ret = safelyRun(fn, void 0).value;
+  hookScopeStack.pop();
+  return ret;
+}
+function sub(key, fn, deps) {
+  return memo(key, () => prism(fn), deps).getValue();
+}
+function inPrism() {
+  return !!hookScopeStack.peek();
+}
+function source(subscribe, getValue2) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.source() is called outside of a prism() call.`);
+  }
+  return scope2.source(subscribe, getValue2);
+}
+var prism = (fn) => {
+  return new PrismInstance(fn);
+};
+var ColdScope = class {
+  effect(key, cb, deps) {
+    console.warn(`prism.effect() does not run in cold prisms`);
+  }
+  memo(key, fn, deps) {
+    return fn();
+  }
+  state(key, initialValue) {
+    return [initialValue, () => {
+    }];
+  }
+  ref(key, initialValue) {
+    return { current: initialValue };
+  }
+  sub(key) {
+    return new ColdScope();
+  }
+  source(subscribe, getValue2) {
+    return getValue2();
+  }
+};
+function calculateColdPrism(fn) {
+  const scope2 = new ColdScope();
+  hookScopeStack.push(scope2);
+  let value;
+  try {
+    value = fn();
+  } catch (error) {
+    console.error(error);
+  } finally {
+    const topOfTheStack = hookScopeStack.pop();
+    if (topOfTheStack !== scope2) {
+      console.warn(`The Prism hook stack has slipped. This is a bug.`);
+    }
+  }
+  return value;
+}
+prism.ref = ref;
+prism.effect = effect;
+prism.memo = memo;
+prism.ensurePrism = ensurePrism;
+prism.state = state;
+prism.scope = scope;
+prism.sub = sub;
+prism.inPrism = inPrism;
+prism.source = source;
+
+// ../dataverse/src/Atom.ts
+var ValueTypes;
+(function(ValueTypes2) {
+  ValueTypes2[ValueTypes2["Dict"] = 0] = "Dict";
+  ValueTypes2[ValueTypes2["Array"] = 1] = "Array";
+  ValueTypes2[ValueTypes2["Other"] = 2] = "Other";
+})(ValueTypes || (ValueTypes = {}));
+
+// ../dataverse/src/pointerToPrism.ts
+var identifyPrismWeakMap = new WeakMap();
+
+// ../dataverse/src/Ticker.ts
+var EMPTY_TICKS_BEFORE_GOING_DORMANT = 60 * 3;
+
+// src/index.ts
+var import_theatre_studio = __toModule(require("@tomorrowevening/theatre-studio"));
+
+// ../../node_modules/lodash-es/_stackClear.js
+function stackClear() {
+  this.__data__ = new ListCache_default();
+  this.size = 0;
+}
+var stackClear_default = stackClear;
+
+// ../../node_modules/lodash-es/_stackDelete.js
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var stackDelete_default = stackDelete;
+
+// ../../node_modules/lodash-es/_stackGet.js
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+var stackGet_default = stackGet;
+
+// ../../node_modules/lodash-es/_stackHas.js
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var stackHas_default = stackHas;
+
+// ../../node_modules/lodash-es/_stackSet.js
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache_default) {
+    var pairs = data.__data__;
+    if (!Map_default || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache_default(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var stackSet_default = stackSet;
+
+// ../../node_modules/lodash-es/_Stack.js
+function Stack2(entries) {
+  var data = this.__data__ = new ListCache_default(entries);
+  this.size = data.size;
+}
+Stack2.prototype.clear = stackClear_default;
+Stack2.prototype["delete"] = stackDelete_default;
+Stack2.prototype.get = stackGet_default;
+Stack2.prototype.has = stackHas_default;
+Stack2.prototype.set = stackSet_default;
+var Stack_default = Stack2;
+
+// ../../node_modules/lodash-es/_setCacheAdd.js
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  this.__data__.set(value, HASH_UNDEFINED3);
+  return this;
+}
+var setCacheAdd_default = setCacheAdd;
+
+// ../../node_modules/lodash-es/_setCacheHas.js
+function setCacheHas(value) {
+  return this.__data__.has(value);
+}
+var setCacheHas_default = setCacheHas;
+
+// ../../node_modules/lodash-es/_SetCache.js
+function SetCache(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache_default();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default;
+SetCache.prototype.has = setCacheHas_default;
+var SetCache_default = SetCache;
+
+// ../../node_modules/lodash-es/_arraySome.js
+function arraySome(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var arraySome_default = arraySome;
+
+// ../../node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache, key) {
+  return cache.has(key);
+}
+var cacheHas_default = cacheHas;
+
+// ../../node_modules/lodash-es/_equalArrays.js
+var COMPARE_PARTIAL_FLAG = 1;
+var COMPARE_UNORDERED_FLAG = 2;
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome_default(other, function(othValue2, othIndex) {
+        if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var equalArrays_default = equalArrays;
+
+// ../../node_modules/lodash-es/_Uint8Array.js
+var Uint8Array2 = root_default.Uint8Array;
+var Uint8Array_default = Uint8Array2;
+
+// ../../node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var mapToArray_default = mapToArray;
+
+// ../../node_modules/lodash-es/_setToArray.js
+function setToArray(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var setToArray_default = setToArray;
+
+// ../../node_modules/lodash-es/_equalByTag.js
+var COMPARE_PARTIAL_FLAG2 = 1;
+var COMPARE_UNORDERED_FLAG2 = 2;
+var boolTag = "[object Boolean]";
+var dateTag = "[object Date]";
+var errorTag = "[object Error]";
+var mapTag = "[object Map]";
+var numberTag = "[object Number]";
+var regexpTag = "[object RegExp]";
+var setTag = "[object Set]";
+var stringTag = "[object String]";
+var symbolTag = "[object Symbol]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var dataViewTag = "[object DataView]";
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object), new Uint8Array_default(other))) {
+        return false;
+      }
+      return true;
+    case boolTag:
+    case dateTag:
+    case numberTag:
+      return eq_default(+object, +other);
+    case errorTag:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag:
+    case stringTag:
+      return object == other + "";
+    case mapTag:
+      var convert = mapToArray_default;
+    case setTag:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      convert || (convert = setToArray_default);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG2;
+      stack.set(object, other);
+      var result = equalArrays_default(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var equalByTag_default = equalByTag;
+
+// ../../node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var arrayPush_default = arrayPush;
+
+// ../../node_modules/lodash-es/_baseGetAllKeys.js
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray_default(object) ? result : arrayPush_default(result, symbolsFunc(object));
+}
+var baseGetAllKeys_default = baseGetAllKeys;
+
+// ../../node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var arrayFilter_default = arrayFilter;
+
+// ../../node_modules/lodash-es/stubArray.js
+function stubArray() {
+  return [];
+}
+var stubArray_default = stubArray;
+
+// ../../node_modules/lodash-es/_getSymbols.js
+var objectProto6 = Object.prototype;
+var propertyIsEnumerable = objectProto6.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray_default : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+var getSymbols_default = getSymbols;
+
+// ../../node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var baseTimes_default = baseTimes;
+
+// ../../node_modules/lodash-es/_baseIsArguments.js
+var argsTag = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike_default(value) && baseGetTag_default(value) == argsTag;
+}
+var baseIsArguments_default = baseIsArguments;
+
+// ../../node_modules/lodash-es/isArguments.js
+var objectProto7 = Object.prototype;
+var hasOwnProperty5 = objectProto7.hasOwnProperty;
+var propertyIsEnumerable2 = objectProto7.propertyIsEnumerable;
+var isArguments = baseIsArguments_default(function() {
+  return arguments;
+}()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty5.call(value, "callee") && !propertyIsEnumerable2.call(value, "callee");
+};
+var isArguments_default = isArguments;
+
+// ../../node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return false;
+}
+var stubFalse_default = stubFalse;
+
+// ../../node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? root_default.Buffer : void 0;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse_default;
+var isBuffer_default = isBuffer;
+
+// ../../node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var isIndex_default = isIndex;
+
+// ../../node_modules/lodash-es/isLength.js
+var MAX_SAFE_INTEGER2 = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER2;
+}
+var isLength_default = isLength;
+
+// ../../node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]";
+var arrayTag = "[object Array]";
+var boolTag2 = "[object Boolean]";
+var dateTag2 = "[object Date]";
+var errorTag2 = "[object Error]";
+var funcTag2 = "[object Function]";
+var mapTag2 = "[object Map]";
+var numberTag2 = "[object Number]";
+var objectTag = "[object Object]";
+var regexpTag2 = "[object RegExp]";
+var setTag2 = "[object Set]";
+var stringTag2 = "[object String]";
+var weakMapTag = "[object WeakMap]";
+var arrayBufferTag2 = "[object ArrayBuffer]";
+var dataViewTag2 = "[object DataView]";
+var float32Tag = "[object Float32Array]";
+var float64Tag = "[object Float64Array]";
+var int8Tag = "[object Int8Array]";
+var int16Tag = "[object Int16Array]";
+var int32Tag = "[object Int32Array]";
+var uint8Tag = "[object Uint8Array]";
+var uint8ClampedTag = "[object Uint8ClampedArray]";
+var uint16Tag = "[object Uint16Array]";
+var uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag2] = typedArrayTags[boolTag2] = typedArrayTags[dataViewTag2] = typedArrayTags[dateTag2] = typedArrayTags[errorTag2] = typedArrayTags[funcTag2] = typedArrayTags[mapTag2] = typedArrayTags[numberTag2] = typedArrayTags[objectTag] = typedArrayTags[regexpTag2] = typedArrayTags[setTag2] = typedArrayTags[stringTag2] = typedArrayTags[weakMapTag] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike_default(value) && isLength_default(value.length) && !!typedArrayTags[baseGetTag_default(value)];
+}
+var baseIsTypedArray_default = baseIsTypedArray;
+
+// ../../node_modules/lodash-es/_baseUnary.js
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var baseUnary_default = baseUnary;
+
+// ../../node_modules/lodash-es/_nodeUtil.js
+var freeExports2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports2 = freeModule2 && freeModule2.exports === freeExports2;
+var freeProcess = moduleExports2 && freeGlobal_default.process;
+var nodeUtil = function() {
+  try {
+    var types2 = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    if (types2) {
+      return types2;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}();
+var nodeUtil_default = nodeUtil;
+
+// ../../node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default;
+var isTypedArray_default = isTypedArray;
+
+// ../../node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto8 = Object.prototype;
+var hasOwnProperty6 = objectProto8.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray_default(value), isArg = !isArr && isArguments_default(value), isBuff = !isArr && !isArg && isBuffer_default(value), isType = !isArr && !isArg && !isBuff && isTypedArray_default(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes_default(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty6.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex_default(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var arrayLikeKeys_default = arrayLikeKeys;
+
+// ../../node_modules/lodash-es/_isPrototype.js
+var objectProto9 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto9;
+  return value === proto;
+}
+var isPrototype_default = isPrototype;
+
+// ../../node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = overArg_default(Object.keys, Object);
+var nativeKeys_default = nativeKeys;
+
+// ../../node_modules/lodash-es/_baseKeys.js
+var objectProto10 = Object.prototype;
+var hasOwnProperty7 = objectProto10.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype_default(object)) {
+    return nativeKeys_default(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty7.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var baseKeys_default = baseKeys;
+
+// ../../node_modules/lodash-es/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// ../../node_modules/lodash-es/keys.js
+function keys(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object) : baseKeys_default(object);
+}
+var keys_default = keys;
+
+// ../../node_modules/lodash-es/_getAllKeys.js
+function getAllKeys(object) {
+  return baseGetAllKeys_default(object, keys_default, getSymbols_default);
+}
+var getAllKeys_default = getAllKeys;
+
+// ../../node_modules/lodash-es/_equalObjects.js
+var COMPARE_PARTIAL_FLAG3 = 1;
+var objectProto11 = Object.prototype;
+var hasOwnProperty8 = objectProto11.hasOwnProperty;
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty8.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var equalObjects_default = equalObjects;
+
+// ../../node_modules/lodash-es/_DataView.js
+var DataView = getNative_default(root_default, "DataView");
+var DataView_default = DataView;
+
+// ../../node_modules/lodash-es/_Promise.js
+var Promise2 = getNative_default(root_default, "Promise");
+var Promise_default = Promise2;
+
+// ../../node_modules/lodash-es/_Set.js
+var Set2 = getNative_default(root_default, "Set");
+var Set_default = Set2;
+
+// ../../node_modules/lodash-es/_WeakMap.js
+var WeakMap2 = getNative_default(root_default, "WeakMap");
+var WeakMap_default = WeakMap2;
+
+// ../../node_modules/lodash-es/_getTag.js
+var mapTag3 = "[object Map]";
+var objectTag2 = "[object Object]";
+var promiseTag = "[object Promise]";
+var setTag3 = "[object Set]";
+var weakMapTag2 = "[object WeakMap]";
+var dataViewTag3 = "[object DataView]";
+var dataViewCtorString = toSource_default(DataView_default);
+var mapCtorString = toSource_default(Map_default);
+var promiseCtorString = toSource_default(Promise_default);
+var setCtorString = toSource_default(Set_default);
+var weakMapCtorString = toSource_default(WeakMap_default);
+var getTag = baseGetTag_default;
+if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag3 || Map_default && getTag(new Map_default()) != mapTag3 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag3 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) {
+  getTag = function(value) {
+    var result = baseGetTag_default(value), Ctor = result == objectTag2 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag3;
+        case mapCtorString:
+          return mapTag3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag3;
+        case weakMapCtorString:
+          return weakMapTag2;
+      }
+    }
+    return result;
+  };
+}
+var getTag_default = getTag;
+
+// ../../node_modules/lodash-es/_baseIsEqualDeep.js
+var COMPARE_PARTIAL_FLAG4 = 1;
+var argsTag3 = "[object Arguments]";
+var arrayTag2 = "[object Array]";
+var objectTag3 = "[object Object]";
+var objectProto12 = Object.prototype;
+var hasOwnProperty9 = objectProto12.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag2 : getTag_default(object), othTag = othIsArr ? arrayTag2 : getTag_default(other);
+  objTag = objTag == argsTag3 ? objectTag3 : objTag;
+  othTag = othTag == argsTag3 ? objectTag3 : othTag;
+  var objIsObj = objTag == objectTag3, othIsObj = othTag == objectTag3, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack_default());
+    return objIsArr || isTypedArray_default(object) ? equalArrays_default(object, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG4)) {
+    var objIsWrapped = objIsObj && hasOwnProperty9.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty9.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack_default());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack_default());
+  return equalObjects_default(object, other, bitmask, customizer, equalFunc, stack);
+}
+var baseIsEqualDeep_default = baseIsEqualDeep;
+
+// ../../node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var baseIsEqual_default = baseIsEqual;
+
+// ../../node_modules/lodash-es/isEqualWith.js
+function isEqualWith(value, other, customizer) {
+  customizer = typeof customizer == "function" ? customizer : void 0;
+  var result = customizer ? customizer(value, other) : void 0;
+  return result === void 0 ? baseIsEqual_default(value, other, void 0, customizer) : !!result;
+}
+var isEqualWith_default = isEqualWith;
+
+// ../../node_modules/lodash-es/isEqual.js
+function isEqual(value, other) {
+  return baseIsEqual_default(value, other);
+}
+var isEqual_default = isEqual;
+
+// src/index.ts
+var import_react = __toModule(require("react"));
+var import_theatre_core3 = __toModule(require("@tomorrowevening/theatre-core"));
+if (process.env.NODE_ENV === "development") {
+  import_theatre_studio.default.initialize();
+}
+var maybeTransaction = process.env.NODE_ENV === "development" ? import_theatre_studio.default.transaction.bind(import_theatre_studio.default) : () => {
+};
+var _projectConfig = void 0;
+function equalityCheckWithFunctionsAlwaysEqual(a, b) {
+  if (typeof a === "function" && typeof b === "function") {
+    return true;
+  }
+}
+function initialize(config) {
+  if (_project) {
+    console.warn("Theatric has already been initialized, either through another initialize call, or by calling useControls() before calling initialize().");
+    return _project.ready.then(() => {
+    });
+  }
+  _projectConfig = config;
+  const project = callGetProject();
+  return project.ready.then(() => {
+  });
+}
+function getAssetUrl(asset) {
+  if (!_project) {
+    throw new Error("Theatric has not been initialized yet. Please call initialize() before calling getAssetUrl().");
+  }
+  if (!_project.isReady) {
+    throw new Error("Calling `getAssetUrl()` before `initialize()` is resolved.\nThe best way to solve this is to delay rendering your react app until `project.ready` is resolved, like this: \n\n```\nproject.ready.then(() => {ReactDom.render(...)})\n```");
+  }
+  return _project.getAssetUrl(asset);
+}
+var allProps = {};
+var allActions = {};
+function useControls(config, options = {}) {
+  var _a, _b, _c;
+  if (_projectConfig === void 0) {
+    _projectConfig = null;
+  }
+  const configRef = (0, import_react.useRef)(config);
+  const _config = (0, import_react.useMemo)(() => {
+    let currentConfig = configRef.current;
+    if (!isEqualWith_default(config, configRef.current, equalityCheckWithFunctionsAlwaysEqual)) {
+      configRef.current = config;
+      currentConfig = config;
+    }
+    return currentConfig;
+  }, [config]);
+  const { folder } = options;
+  const controlsWithoutButtons = (0, import_react.useMemo)(() => Object.fromEntries(Object.entries(_config).filter(([key, value]) => value.type !== "button")), [_config]);
+  const buttons = (0, import_react.useMemo)(() => Object.fromEntries(Object.entries(_config).filter(([key, value]) => value.type === "button")), [_config]);
+  const props = (0, import_react.useMemo)(() => folder ? { [folder]: controlsWithoutButtons } : controlsWithoutButtons, [folder, controlsWithoutButtons]);
+  const actions = (0, import_react.useMemo)(() => Object.fromEntries(Object.entries(buttons).map(([key, value]) => [
+    `${folder ? `${folder}: ` : ""}${key}`,
+    () => {
+      var _a2, _b2;
+      (_b2 = (_a2 = configRef.current[key]).onClick) == null ? void 0 : _b2.call(_a2);
+    }
+  ])), [buttons, folder]);
+  const sheet = (0, import_react.useMemo)(() => callGetProject().sheet("Panels"), []);
+  const panel = (_a = options.panel) != null ? _a : "Default panel";
+  const allPanelProps = (_b = allProps[panel]) != null ? _b : allProps[panel] = [];
+  const allPanelActions = (_c = allActions[panel]) != null ? _c : allActions[panel] = [];
+  const object = (0, import_react.useMemo)(() => sheet.object(panel, Object.assign({}, ...allProps[panel], props), {
+    reconfigure: true,
+    __actions__THIS_API_IS_UNSTABLE_AND_WILL_CHANGE_IN_THE_NEXT_VERSION: Object.assign({}, ...allActions[panel], actions)
+  }), [panel, props, actions]);
+  (0, import_react.useEffect)(() => {
+    allPanelProps.push(props);
+    allPanelActions.push(actions);
+    let obj = sheet.object(panel, Object.assign({}, ...allPanelProps), {
+      reconfigure: true,
+      __actions__THIS_API_IS_UNSTABLE_AND_WILL_CHANGE_IN_THE_NEXT_VERSION: Object.assign({}, ...allPanelActions)
+    });
+    selectObjectIfNecessary(obj);
+    return () => {
+      allPanelProps.splice(allPanelProps.indexOf(props), 1);
+      allActions[panel].splice(allPanelActions.indexOf(actions), 1);
+      sheet.object(panel, Object.assign({}, ...allPanelProps), {
+        reconfigure: true,
+        __actions__THIS_API_IS_UNSTABLE_AND_WILL_CHANGE_IN_THE_NEXT_VERSION: Object.assign({}, ...allPanelActions)
+      });
+    };
+  }, [props, actions, allPanelActions, allPanelProps, sheet, panel]);
+  const [values, setValues] = (0, import_react.useState)(folder ? object.value[folder] : object.value);
+  const valuesRef = (0, import_react.useRef)(object.value);
+  (0, import_react.useEffect)(() => {
+    const unsub = object.onValuesChange((newValues) => {
+      if (folder)
+        newValues = newValues[folder];
+      if (isEqual_default(newValues, valuesRef.current))
+        return;
+      valuesRef.current = newValues;
+      setValues(newValues);
+    });
+    return unsub;
+  }, [object]);
+  const $setAndGet = (0, import_react.useMemo)(() => {
+    const rootPointer = folder ? object.props[folder] : object.props;
+    const $set = (getPointer, value) => {
+      if (typeof getPointer !== "function") {
+        throw new Error(`The first argument to $set must be a function that returns a pointer. Instead, it was ${typeof getPointer}`);
+      }
+      const pointer = getPointer(rootPointer);
+      if (!isPointer(pointer)) {
+        throw new Error(`The function passed to $set must return a pointer. Instead, it returned ${pointer}`);
+      }
+      maybeTransaction((api) => {
+        api.set(pointer, value);
+      });
+    };
+    const $get = (getPointer) => {
+      if (typeof getPointer !== "function") {
+        throw new Error(`The first argument to $get must be a function that returns a pointer. Instead, it was ${typeof getPointer}`);
+      }
+      const pointer = getPointer(rootPointer);
+      if (!isPointer(pointer)) {
+        throw new Error(`The function passed to $get must return a pointer. Instead, it returned ${pointer}`);
+      }
+      return (0, import_theatre_core.val)(pointer);
+    };
+    return { $set, $get };
+  }, [folder, object]);
+  return __spreadValues(__spreadValues({}, values), $setAndGet);
+}
+var button = (onClick) => {
+  return {
+    type: "button",
+    onClick
+  };
+};
+var _project;
+function callGetProject() {
+  if (_project)
+    return _project;
+  _project = (0, import_theatre_core2.getProject)("Theatric", _projectConfig != null ? _projectConfig : void 0);
+  return _project;
+}
+var objAlreadySelected = false;
+function selectObjectIfNecessary(obj) {
+  if (objAlreadySelected)
+    return;
+  objAlreadySelected = true;
+  if (process.env.NODE_ENV === "development") {
+    if (import_theatre_studio.default.selection.length === 0) {
+      import_theatre_studio.default.setSelection([obj]);
+    }
+  }
+}
+//# sourceMappingURL=index.js.map