@tomorrowevening/theatre-core 1.0.0

package/dist/index.js

@@ -0,0 +1,3973 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropNames = Object.getOwnPropertyNames, __getOwnPropSymbols = Object.getOwnPropertySymbols, __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __knownSymbol = (name, symbol) => {
+  if (symbol = Symbol[name])
+    return symbol;
+  throw Error("Symbol." + name + " is not defined");
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b))
+      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var __publicField = (obj, key, value) => (__defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value), value);
+var __await = function(promise, isYieldStar) {
+  this[0] = promise, this[1] = isYieldStar;
+};
+var __yieldStar = (value) => {
+  var obj = value[__knownSymbol("asyncIterator")], isAwait = !1, method, it = {};
+  return obj == null ? (obj = value[__knownSymbol("iterator")](), method = (k) => it[k] = (x) => obj[k](x)) : (obj = obj.call(value), method = (k) => it[k] = (v) => {
+    if (isAwait) {
+      if (isAwait = !1, k === "throw")
+        throw v;
+      return v;
+    }
+    return isAwait = !0, {
+      done: !1,
+      value: new __await(new Promise((resolve) => {
+        var x = obj[k](v);
+        if (!(x instanceof Object))
+          throw TypeError("Object expected");
+        resolve(x);
+      }), 1)
+    };
+  }), it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
+    throw x;
+  }, "return" in obj && method("return"), it;
+};
+
+// ../../node_modules/timing-function/lib/UnitBezier.js
+var require_UnitBezier = __commonJS({
+  "../../node_modules/timing-function/lib/UnitBezier.js"(exports2, module2) {
+    var UnitBezier2;
+    module2.exports = UnitBezier2 = function() {
+      function UnitBezier3(p1x, p1y, p2x, p2y) {
+        this.set(p1x, p1y, p2x, p2y);
+      }
+      return UnitBezier3.prototype.set = function(p1x, p1y, p2x, p2y) {
+        this._cx = 3 * p1x, this._bx = 3 * (p2x - p1x) - this._cx, this._ax = 1 - this._cx - this._bx, this._cy = 3 * p1y, this._by = 3 * (p2y - p1y) - this._cy, this._ay = 1 - this._cy - this._by;
+      }, UnitBezier3.epsilon = 1e-6, UnitBezier3.prototype._sampleCurveX = function(t) {
+        return ((this._ax * t + this._bx) * t + this._cx) * t;
+      }, UnitBezier3.prototype._sampleCurveY = function(t) {
+        return ((this._ay * t + this._by) * t + this._cy) * t;
+      }, UnitBezier3.prototype._sampleCurveDerivativeX = function(t) {
+        return (3 * this._ax * t + 2 * this._bx) * t + this._cx;
+      }, UnitBezier3.prototype._solveCurveX = function(x, epsilon) {
+        var d2, i, t0, t1, t2, x2;
+        for (t0 = void 0, t1 = void 0, t2 = void 0, x2 = void 0, d2 = void 0, i = void 0, t2 = x, i = 0; i < 8; ) {
+          if (x2 = this._sampleCurveX(t2) - x, Math.abs(x2) < epsilon)
+            return t2;
+          if (d2 = this._sampleCurveDerivativeX(t2), Math.abs(d2) < epsilon)
+            break;
+          t2 = t2 - x2 / d2, i++;
+        }
+        if (t0 = 0, t1 = 1, t2 = x, t2 < t0)
+          return t0;
+        if (t2 > t1)
+          return t1;
+        for (; t0 < t1; ) {
+          if (x2 = this._sampleCurveX(t2), Math.abs(x2 - x) < epsilon)
+            return t2;
+          x > x2 ? t0 = t2 : t1 = t2, t2 = (t1 - t0) * 0.5 + t0;
+        }
+        return t2;
+      }, UnitBezier3.prototype.solve = function(x, epsilon) {
+        return this._sampleCurveY(this._solveCurveX(x, epsilon));
+      }, UnitBezier3.prototype.solveSimple = function(x) {
+        return this._sampleCurveY(this._solveCurveX(x, 1e-6));
+      }, UnitBezier3;
+    }();
+  }
+});
+
+// ../../node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "../../node_modules/fast-deep-equal/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function equal(a, b) {
+      if (a === b)
+        return !0;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor)
+          return !1;
+        var length, i, keys2;
+        if (Array.isArray(a)) {
+          if (length = a.length, length != b.length)
+            return !1;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i]))
+              return !1;
+          return !0;
+        }
+        if (a.constructor === RegExp)
+          return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf)
+          return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString)
+          return a.toString() === b.toString();
+        if (keys2 = Object.keys(a), length = keys2.length, length !== Object.keys(b).length)
+          return !1;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys2[i]))
+            return !1;
+        for (i = length; i-- !== 0; ) {
+          var key = keys2[i];
+          if (!equal(a[key], b[key]))
+            return !1;
+        }
+        return !0;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  __private: () => __private,
+  createRafDriver: () => createRafDriver,
+  default: () => src_default,
+  getProject: () => getProject,
+  getStudio: () => getStudio,
+  getStudioSync: () => getStudioSync,
+  init: () => init,
+  notify: () => notify,
+  onChange: () => onChange,
+  propTypeSymbol: () => propTypeSymbol,
+  types: () => propTypes_exports,
+  val: () => val8
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/coreExports.ts
+var coreExports_exports = {};
+__export(coreExports_exports, {
+  __private: () => __private,
+  createRafDriver: () => createRafDriver,
+  getProject: () => getProject,
+  notify: () => notify,
+  onChange: () => onChange,
+  types: () => propTypes_exports,
+  val: () => val8
+});
+
+// src/projects/projectsSingleton.ts
+var import_dataverse = require("@theatre/dataverse");
+var ProjectsSingleton = class {
+  constructor() {
+    __publicField(this, "atom", new import_dataverse.Atom({ projects: {} }));
+  }
+  /**
+   * We're trusting here that each project id is unique
+   */
+  add(id, project) {
+    this.atom.setByPointer((p) => p.projects[id], project);
+  }
+  get(id) {
+    return this.atom.get().projects[id];
+  }
+  has(id) {
+    return !!this.get(id);
+  }
+}, singleton = new ProjectsSingleton(), projectsSingleton_default = singleton;
+
+// src/privateAPIs.ts
+var publicAPIToPrivateAPIMap = /* @__PURE__ */ new WeakMap();
+function privateAPI(pub) {
+  return publicAPIToPrivateAPIMap.get(pub);
+}
+function setPrivateAPI(pub, priv) {
+  publicAPIToPrivateAPIMap.set(pub, priv);
+}
+
+// src/sheetObjects/SheetObjectTemplate.ts
+var import_utils3 = require("@theatre/utils"), import_getDeep = __toESM(require("@theatre/utils/getDeep")), import_SimpleCache3 = __toESM(require("@theatre/utils/SimpleCache")), import_dataverse5 = require("@theatre/dataverse");
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global, freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self, root = freeGlobal_default || freeSelf || Function("return this")(), root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol, Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype, hasOwnProperty = objectProto.hasOwnProperty, nativeObjectToString = objectProto.toString, 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 = !0;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  return unmasked && (isOwn ? value[symToStringTag] = tag : delete value[symToStringTag]), result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype, nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]", symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  return value == null ? value === void 0 ? undefinedTag : nullTag : symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../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]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value))
+    return !1;
+  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__"], 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, 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, reIsHostCtor = /^\[object .+?Constructor\]$/, funcProto2 = Function.prototype, objectProto3 = Object.prototype, funcToString2 = funcProto2.toString, hasOwnProperty2 = objectProto3.hasOwnProperty, reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value))
+    return !1;
+  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/_defineProperty.js
+var defineProperty = function() {
+  try {
+    var func = getNative_default(Object, "defineProperty");
+    return func({}, "", {}), func;
+  } catch (e) {
+  }
+}(), defineProperty_default = defineProperty;
+
+// ../../node_modules/lodash-es/_baseAssignValue.js
+function baseAssignValue(object, key, value) {
+  key == "__proto__" && defineProperty_default ? defineProperty_default(object, key, {
+    configurable: !0,
+    enumerable: !0,
+    value,
+    writable: !0
+  }) : object[key] = value;
+}
+var baseAssignValue_default = baseAssignValue;
+
+// ../../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/_assignValue.js
+var objectProto4 = Object.prototype, hasOwnProperty3 = objectProto4.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  (!(hasOwnProperty3.call(object, key) && eq_default(objValue, value)) || value === void 0 && !(key in object)) && baseAssignValue_default(object, key, value);
+}
+var assignValue_default = assignValue;
+
+// ../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray, isArray_default = isArray;
+
+// ../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/lodash-es/isSymbol.js
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike_default(value) && baseGetTag_default(value) == symbolTag;
+}
+var isSymbol_default = isSymbol;
+
+// ../../node_modules/lodash-es/_isKey.js
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value))
+    return !1;
+  var type = typeof value;
+  return type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value) ? !0 : reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var isKey_default = isKey;
+
+// ../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create"), 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];
+  return this.size -= result ? 1 : 0, result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__", objectProto5 = Object.prototype, hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty4.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../node_modules/lodash-es/_hashHas.js
+var objectProto6 = Object.prototype, hasOwnProperty5 = objectProto6.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty5.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__;
+  return this.size += this.has(key) ? 0 : 1, data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value, this;
+}
+var hashSet_default = hashSet;
+
+// ../../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++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/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  for (var length = array.length; 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, splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0)
+    return !1;
+  var lastIndex = data.length - 1;
+  return index == lastIndex ? data.pop() : splice.call(data, index, 1), --this.size, !0;
+}
+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);
+  return index < 0 ? (++this.size, data.push([key, value])) : data[index][1] = value, this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++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"), 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);
+  return this.size -= result ? 1 : 0, 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;
+  return data.set(key, value), this.size += data.size == size ? 0 : 1, this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  for (this.clear(); ++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/memoize.js
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function")
+    throw new TypeError(FUNC_ERROR_TEXT);
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache2 = memoized.cache;
+    if (cache2.has(key))
+      return cache2.get(key);
+    var result = func.apply(this, args);
+    return memoized.cache = cache2.set(key, result) || cache2, result;
+  };
+  return memoized.cache = new (memoize.Cache || MapCache_default)(), memoized;
+}
+memoize.Cache = MapCache_default;
+var memoize_default = memoize;
+
+// ../../node_modules/lodash-es/_memoizeCapped.js
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize_default(func, function(key) {
+    return cache2.size === MAX_MEMOIZE_SIZE && cache2.clear(), key;
+  }), cache2 = result.cache;
+  return result;
+}
+var memoizeCapped_default = memoizeCapped;
+
+// ../../node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, reEscapeChar = /\\(\\)?/g, stringToPath = memoizeCapped_default(function(string2) {
+  var result = [];
+  return string2.charCodeAt(0) === 46 && result.push(""), string2.replace(rePropName, function(match, number2, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number2 || match);
+  }), result;
+}), stringToPath_default = stringToPath;
+
+// ../../node_modules/lodash-es/_arrayMap.js
+function arrayMap(array, iteratee) {
+  for (var index = -1, length = array == null ? 0 : array.length, result = Array(length); ++index < length; )
+    result[index] = iteratee(array[index], index, array);
+  return result;
+}
+var arrayMap_default = arrayMap;
+
+// ../../node_modules/lodash-es/_baseToString.js
+var INFINITY = 1 / 0, symbolProto = Symbol_default ? Symbol_default.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string")
+    return value;
+  if (isArray_default(value))
+    return arrayMap_default(value, baseToString) + "";
+  if (isSymbol_default(value))
+    return symbolToString ? symbolToString.call(value) : "";
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+var baseToString_default = baseToString;
+
+// ../../node_modules/lodash-es/toString.js
+function toString(value) {
+  return value == null ? "" : baseToString_default(value);
+}
+var toString_default = toString;
+
+// ../../node_modules/lodash-es/_castPath.js
+function castPath(value, object) {
+  return isArray_default(value) ? value : isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
+}
+var castPath_default = castPath;
+
+// ../../node_modules/lodash-es/_isIndex.js
+var MAX_SAFE_INTEGER = 9007199254740991, reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  return length = length == null ? MAX_SAFE_INTEGER : length, !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+}
+var isIndex_default = isIndex;
+
+// ../../node_modules/lodash-es/_toKey.js
+var INFINITY2 = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol_default(value))
+    return value;
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY2 ? "-0" : result;
+}
+var toKey_default = toKey;
+
+// ../../node_modules/lodash-es/_baseSet.js
+function baseSet(object, path, value, customizer) {
+  if (!isObject_default(object))
+    return object;
+  path = castPath_default(path, object);
+  for (var index = -1, length = path.length, lastIndex = length - 1, nested = object; nested != null && ++index < length; ) {
+    var key = toKey_default(path[index]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype")
+      return object;
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = customizer ? customizer(objValue, key, nested) : void 0, newValue === void 0 && (newValue = isObject_default(objValue) ? objValue : isIndex_default(path[index + 1]) ? [] : {});
+    }
+    assignValue_default(nested, key, newValue), nested = nested[key];
+  }
+  return object;
+}
+var baseSet_default = baseSet;
+
+// ../../node_modules/lodash-es/set.js
+function set(object, path, value) {
+  return object == null ? object : baseSet_default(object, path, value);
+}
+var set_default = set;
+
+// src/sheetObjects/getPropDefaultsOfSheetObject.ts
+var cachedDefaults = /* @__PURE__ */ new WeakMap();
+function getPropDefaultsOfSheetObject(config) {
+  return getDefaultsOfPropTypeConfig(config);
+}
+function getDefaultsOfPropTypeConfig(config) {
+  if (cachedDefaults.has(config))
+    return cachedDefaults.get(config);
+  let generated = config.type === "compound" ? generateDefaultsForCompound(config) : config.type === "enum" ? generateDefaultsForEnum(config) : config.default;
+  return cachedDefaults.set(config, generated), generated;
+}
+function generateDefaultsForEnum(config) {
+  let defaults = {
+    $case: config.defaultCase
+  };
+  for (let [case_, caseConf] of Object.entries(config.cases))
+    defaults[case_] = getDefaultsOfPropTypeConfig(caseConf);
+  return defaults;
+}
+function generateDefaultsForCompound(config) {
+  let defaults = {};
+  for (let [key, propConf] of Object.entries(config.props))
+    defaults[key] = getDefaultsOfPropTypeConfig(propConf);
+  return defaults;
+}
+
+// src/sequences/interpolationTripleAtPosition.ts
+var import_dataverse2 = require("@theatre/dataverse"), import_UnitBezier = __toESM(require_UnitBezier());
+
+// src/utils/keyframeUtils.ts
+var keyframeUtils_exports = {};
+__export(keyframeUtils_exports, {
+  fromArray: () => fromArray,
+  fromSortedKeyframesCached: () => fromSortedKeyframesCached,
+  getSortedKeyframes: () => getSortedKeyframes,
+  getSortedKeyframesCached: () => getSortedKeyframesCached
+});
+var import_memoizeFn = __toESM(require("@theatre/utils/memoizeFn"));
+
+// ../../node_modules/lodash-es/_trimmedEndIndex.js
+var reWhitespace = /\s/;
+function trimmedEndIndex(string2) {
+  for (var index = string2.length; index-- && reWhitespace.test(string2.charAt(index)); )
+    ;
+  return index;
+}
+var trimmedEndIndex_default = trimmedEndIndex;
+
+// ../../node_modules/lodash-es/_baseTrim.js
+var reTrimStart = /^\s+/;
+function baseTrim(string2) {
+  return string2 && string2.slice(0, trimmedEndIndex_default(string2) + 1).replace(reTrimStart, "");
+}
+var baseTrim_default = baseTrim;
+
+// ../../node_modules/lodash-es/toNumber.js
+var NAN = 0 / 0, reIsBadHex = /^[-+]0x[0-9a-f]+$/i, reIsBinary = /^0b[01]+$/i, reIsOctal = /^0o[0-7]+$/i, freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == "number")
+    return value;
+  if (isSymbol_default(value))
+    return NAN;
+  if (isObject_default(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject_default(other) ? other + "" : other;
+  }
+  if (typeof value != "string")
+    return value === 0 ? value : +value;
+  value = baseTrim_default(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+var toNumber_default = toNumber;
+
+// ../../node_modules/lodash-es/toFinite.js
+var INFINITY3 = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite(value) {
+  if (!value)
+    return value === 0 ? value : 0;
+  if (value = toNumber_default(value), value === INFINITY3 || value === -INFINITY3) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var toFinite_default = toFinite;
+
+// ../../node_modules/lodash-es/toInteger.js
+function toInteger(value) {
+  var result = toFinite_default(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_default = toInteger;
+
+// ../../node_modules/lodash-es/identity.js
+function identity(value) {
+  return value;
+}
+var identity_default = identity;
+
+// ../../node_modules/lodash-es/_WeakMap.js
+var WeakMap2 = getNative_default(root_default, "WeakMap"), WeakMap_default = WeakMap2;
+
+// ../../node_modules/lodash-es/_baseCreate.js
+var objectCreate = Object.create, baseCreate = function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject_default(proto))
+      return {};
+    if (objectCreate)
+      return objectCreate(proto);
+    object.prototype = proto;
+    var result = new object();
+    return object.prototype = void 0, result;
+  };
+}(), baseCreate_default = baseCreate;
+
+// ../../node_modules/lodash-es/_copyArray.js
+function copyArray(source, array) {
+  var index = -1, length = source.length;
+  for (array || (array = Array(length)); ++index < length; )
+    array[index] = source[index];
+  return array;
+}
+var copyArray_default = copyArray;
+
+// ../../node_modules/lodash-es/_arrayEach.js
+function arrayEach(array, iteratee) {
+  for (var index = -1, length = array == null ? 0 : array.length; ++index < length && iteratee(array[index], index, array) !== !1; )
+    ;
+  return array;
+}
+var arrayEach_default = arrayEach;
+
+// ../../node_modules/lodash-es/_copyObject.js
+function copyObject(source, props, object, customizer) {
+  var isNew = !object;
+  object || (object = {});
+  for (var index = -1, length = props.length; ++index < length; ) {
+    var key = props[index], newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
+    newValue === void 0 && (newValue = source[key]), isNew ? baseAssignValue_default(object, key, newValue) : assignValue_default(object, key, newValue);
+  }
+  return object;
+}
+var copyObject_default = copyObject;
+
+// ../../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/isArrayLike.js
+function isArrayLike(value) {
+  return value != null && isLength_default(value.length) && !isFunction_default(value);
+}
+var isArrayLike_default = isArrayLike;
+
+// ../../node_modules/lodash-es/_isPrototype.js
+var objectProto7 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto7;
+  return value === proto;
+}
+var isPrototype_default = isPrototype;
+
+// ../../node_modules/lodash-es/_baseTimes.js
+function baseTimes(n, iteratee) {
+  for (var index = -1, result = Array(n); ++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 objectProto8 = Object.prototype, hasOwnProperty6 = objectProto8.hasOwnProperty, propertyIsEnumerable = objectProto8.propertyIsEnumerable, isArguments = baseIsArguments_default(function() {
+  return arguments;
+}()) ? baseIsArguments_default : function(value) {
+  return isObjectLike_default(value) && hasOwnProperty6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+}, isArguments_default = isArguments;
+
+// ../../node_modules/lodash-es/stubFalse.js
+function stubFalse() {
+  return !1;
+}
+var stubFalse_default = stubFalse;
+
+// ../../node_modules/lodash-es/isBuffer.js
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports, freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module, moduleExports = freeModule && freeModule.exports === freeExports, Buffer2 = moduleExports ? root_default.Buffer : void 0, nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0, isBuffer = nativeIsBuffer || stubFalse_default, isBuffer_default = isBuffer;
+
+// ../../node_modules/lodash-es/_baseIsTypedArray.js
+var argsTag2 = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag2 = "[object Function]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", weakMapTag = "[object WeakMap]", arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]", typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = !0;
+typedArrayTags[argsTag2] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag2] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = !1;
+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, freeModule2 = freeExports2 && typeof module == "object" && module && !module.nodeType && module, moduleExports2 = freeModule2 && freeModule2.exports === freeExports2, freeProcess = moduleExports2 && freeGlobal_default.process, nodeUtil = function() {
+  try {
+    var types = freeModule2 && freeModule2.require && freeModule2.require("util").types;
+    return types || freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+}(), nodeUtil_default = nodeUtil;
+
+// ../../node_modules/lodash-es/isTypedArray.js
+var nodeIsTypedArray = nodeUtil_default && nodeUtil_default.isTypedArray, isTypedArray = nodeIsTypedArray ? baseUnary_default(nodeIsTypedArray) : baseIsTypedArray_default, isTypedArray_default = isTypedArray;
+
+// ../../node_modules/lodash-es/_arrayLikeKeys.js
+var objectProto9 = Object.prototype, hasOwnProperty7 = objectProto9.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)
+    (inherited || hasOwnProperty7.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex_default(key, length))) && result.push(key);
+  return result;
+}
+var arrayLikeKeys_default = arrayLikeKeys;
+
+// ../../node_modules/lodash-es/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// ../../node_modules/lodash-es/_nativeKeys.js
+var nativeKeys = overArg_default(Object.keys, Object), nativeKeys_default = nativeKeys;
+
+// ../../node_modules/lodash-es/_baseKeys.js
+var objectProto10 = Object.prototype, hasOwnProperty8 = objectProto10.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype_default(object))
+    return nativeKeys_default(object);
+  var result = [];
+  for (var key in Object(object))
+    hasOwnProperty8.call(object, key) && key != "constructor" && result.push(key);
+  return result;
+}
+var baseKeys_default = baseKeys;
+
+// ../../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/_nativeKeysIn.js
+function nativeKeysIn(object) {
+  var result = [];
+  if (object != null)
+    for (var key in Object(object))
+      result.push(key);
+  return result;
+}
+var nativeKeysIn_default = nativeKeysIn;
+
+// ../../node_modules/lodash-es/_baseKeysIn.js
+var objectProto11 = Object.prototype, hasOwnProperty9 = objectProto11.hasOwnProperty;
+function baseKeysIn(object) {
+  if (!isObject_default(object))
+    return nativeKeysIn_default(object);
+  var isProto = isPrototype_default(object), result = [];
+  for (var key in object)
+    key == "constructor" && (isProto || !hasOwnProperty9.call(object, key)) || result.push(key);
+  return result;
+}
+var baseKeysIn_default = baseKeysIn;
+
+// ../../node_modules/lodash-es/keysIn.js
+function keysIn(object) {
+  return isArrayLike_default(object) ? arrayLikeKeys_default(object, !0) : baseKeysIn_default(object);
+}
+var keysIn_default = keysIn;
+
+// ../../node_modules/lodash-es/_baseGet.js
+function baseGet(object, path) {
+  path = castPath_default(path, object);
+  for (var index = 0, length = path.length; object != null && index < length; )
+    object = object[toKey_default(path[index++])];
+  return index && index == length ? object : void 0;
+}
+var baseGet_default = baseGet;
+
+// ../../node_modules/lodash-es/get.js
+function get(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet_default(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+var get_default = get;
+
+// ../../node_modules/lodash-es/_arrayPush.js
+function arrayPush(array, values) {
+  for (var index = -1, length = values.length, offset = array.length; ++index < length; )
+    array[offset + index] = values[index];
+  return array;
+}
+var arrayPush_default = arrayPush;
+
+// ../../node_modules/lodash-es/_getPrototype.js
+var getPrototype = overArg_default(Object.getPrototypeOf, Object), getPrototype_default = getPrototype;
+
+// ../../node_modules/lodash-es/isPlainObject.js
+var objectTag2 = "[object Object]", funcProto3 = Function.prototype, objectProto12 = Object.prototype, funcToString3 = funcProto3.toString, hasOwnProperty10 = objectProto12.hasOwnProperty, objectCtorString = funcToString3.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag2)
+    return !1;
+  var proto = getPrototype_default(value);
+  if (proto === null)
+    return !0;
+  var Ctor = hasOwnProperty10.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
+}
+var isPlainObject_default = isPlainObject;
+
+// ../../node_modules/lodash-es/_baseSlice.js
+function baseSlice(array, start, end) {
+  var index = -1, length = array.length;
+  start < 0 && (start = -start > length ? 0 : length + start), end = end > length ? length : end, end < 0 && (end += length), length = start > end ? 0 : end - start >>> 0, start >>>= 0;
+  for (var result = Array(length); ++index < length; )
+    result[index] = array[index + start];
+  return result;
+}
+var baseSlice_default = baseSlice;
+
+// ../../node_modules/lodash-es/_castSlice.js
+function castSlice(array, start, end) {
+  var length = array.length;
+  return end = end === void 0 ? length : end, !start && end >= length ? array : baseSlice_default(array, start, end);
+}
+var castSlice_default = castSlice;
+
+// ../../node_modules/lodash-es/_hasUnicode.js
+var rsAstralRange = "\\ud800-\\udfff", rsComboMarksRange = "\\u0300-\\u036f", reComboHalfMarksRange = "\\ufe20-\\ufe2f", rsComboSymbolsRange = "\\u20d0-\\u20ff", rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange, rsVarRange = "\\ufe0e\\ufe0f", rsZWJ = "\\u200d", reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]");
+function hasUnicode(string2) {
+  return reHasUnicode.test(string2);
+}
+var hasUnicode_default = hasUnicode;
+
+// ../../node_modules/lodash-es/_asciiToArray.js
+function asciiToArray(string2) {
+  return string2.split("");
+}
+var asciiToArray_default = asciiToArray;
+
+// ../../node_modules/lodash-es/_unicodeToArray.js
+var rsAstralRange2 = "\\ud800-\\udfff", rsComboMarksRange2 = "\\u0300-\\u036f", reComboHalfMarksRange2 = "\\ufe20-\\ufe2f", rsComboSymbolsRange2 = "\\u20d0-\\u20ff", rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2, rsVarRange2 = "\\ufe0e\\ufe0f", rsAstral = "[" + rsAstralRange2 + "]", rsCombo = "[" + rsComboRange2 + "]", rsFitz = "\\ud83c[\\udffb-\\udfff]", rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")", rsNonAstral = "[^" + rsAstralRange2 + "]", rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ2 = "\\u200d", reOptMod = rsModifier + "?", rsOptVar = "[" + rsVarRange2 + "]?", rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*", rsSeq = rsOptVar + reOptMod + rsOptJoin, rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")", reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
+function unicodeToArray(string2) {
+  return string2.match(reUnicode) || [];
+}
+var unicodeToArray_default = unicodeToArray;
+
+// ../../node_modules/lodash-es/_stringToArray.js
+function stringToArray(string2) {
+  return hasUnicode_default(string2) ? unicodeToArray_default(string2) : asciiToArray_default(string2);
+}
+var stringToArray_default = stringToArray;
+
+// ../../node_modules/lodash-es/_baseClamp.js
+function baseClamp(number2, lower, upper) {
+  return number2 === number2 && (upper !== void 0 && (number2 = number2 <= upper ? number2 : upper), lower !== void 0 && (number2 = number2 >= lower ? number2 : lower)), number2;
+}
+var baseClamp_default = baseClamp;
+
+// ../../node_modules/lodash-es/clamp.js
+function clamp(number2, lower, upper) {
+  return upper === void 0 && (upper = lower, lower = void 0), upper !== void 0 && (upper = toNumber_default(upper), upper = upper === upper ? upper : 0), lower !== void 0 && (lower = toNumber_default(lower), lower = lower === lower ? lower : 0), baseClamp_default(toNumber_default(number2), lower, upper);
+}
+var clamp_default = clamp;
+
+// ../../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);
+  return this.size = data.size, 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)
+      return pairs.push([key, value]), this.size = ++data.size, this;
+    data = this.__data__ = new MapCache_default(pairs);
+  }
+  return data.set(key, value), this.size = data.size, this;
+}
+var stackSet_default = stackSet;
+
+// ../../node_modules/lodash-es/_Stack.js
+function Stack(entries) {
+  var data = this.__data__ = new ListCache_default(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear_default;
+Stack.prototype.delete = stackDelete_default;
+Stack.prototype.get = stackGet_default;
+Stack.prototype.has = stackHas_default;
+Stack.prototype.set = stackSet_default;
+var Stack_default = Stack;
+
+// ../../node_modules/lodash-es/_baseAssign.js
+function baseAssign(object, source) {
+  return object && copyObject_default(source, keys_default(source), object);
+}
+var baseAssign_default = baseAssign;
+
+// ../../node_modules/lodash-es/_baseAssignIn.js
+function baseAssignIn(object, source) {
+  return object && copyObject_default(source, keysIn_default(source), object);
+}
+var baseAssignIn_default = baseAssignIn;
+
+// ../../node_modules/lodash-es/_cloneBuffer.js
+var freeExports3 = typeof exports == "object" && exports && !exports.nodeType && exports, freeModule3 = freeExports3 && typeof module == "object" && module && !module.nodeType && module, moduleExports3 = freeModule3 && freeModule3.exports === freeExports3, Buffer3 = moduleExports3 ? root_default.Buffer : void 0, allocUnsafe = Buffer3 ? Buffer3.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  if (isDeep)
+    return buffer.slice();
+  var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
+  return buffer.copy(result), result;
+}
+var cloneBuffer_default = cloneBuffer;
+
+// ../../node_modules/lodash-es/_arrayFilter.js
+function arrayFilter(array, predicate) {
+  for (var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = []; ++index < length; ) {
+    var value = array[index];
+    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 objectProto13 = Object.prototype, propertyIsEnumerable2 = objectProto13.propertyIsEnumerable, nativeGetSymbols = Object.getOwnPropertySymbols, getSymbols = nativeGetSymbols ? function(object) {
+  return object == null ? [] : (object = Object(object), arrayFilter_default(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable2.call(object, symbol);
+  }));
+} : stubArray_default, getSymbols_default = getSymbols;
+
+// ../../node_modules/lodash-es/_copySymbols.js
+function copySymbols(source, object) {
+  return copyObject_default(source, getSymbols_default(source), object);
+}
+var copySymbols_default = copySymbols;
+
+// ../../node_modules/lodash-es/_getSymbolsIn.js
+var nativeGetSymbols2 = Object.getOwnPropertySymbols, getSymbolsIn = nativeGetSymbols2 ? function(object) {
+  for (var result = []; object; )
+    arrayPush_default(result, getSymbols_default(object)), object = getPrototype_default(object);
+  return result;
+} : stubArray_default, getSymbolsIn_default = getSymbolsIn;
+
+// ../../node_modules/lodash-es/_copySymbolsIn.js
+function copySymbolsIn(source, object) {
+  return copyObject_default(source, getSymbolsIn_default(source), object);
+}
+var copySymbolsIn_default = copySymbolsIn;
+
+// ../../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/_getAllKeys.js
+function getAllKeys(object) {
+  return baseGetAllKeys_default(object, keys_default, getSymbols_default);
+}
+var getAllKeys_default = getAllKeys;
+
+// ../../node_modules/lodash-es/_getAllKeysIn.js
+function getAllKeysIn(object) {
+  return baseGetAllKeys_default(object, keysIn_default, getSymbolsIn_default);
+}
+var getAllKeysIn_default = getAllKeysIn;
+
+// ../../node_modules/lodash-es/_DataView.js
+var DataView = getNative_default(root_default, "DataView"), DataView_default = DataView;
+
+// ../../node_modules/lodash-es/_Promise.js
+var Promise2 = getNative_default(root_default, "Promise"), Promise_default = Promise2;
+
+// ../../node_modules/lodash-es/_Set.js
+var Set = getNative_default(root_default, "Set"), Set_default = Set;
+
+// ../../node_modules/lodash-es/_getTag.js
+var mapTag2 = "[object Map]", objectTag3 = "[object Object]", promiseTag = "[object Promise]", setTag2 = "[object Set]", weakMapTag2 = "[object WeakMap]", dataViewTag2 = "[object DataView]", dataViewCtorString = toSource_default(DataView_default), mapCtorString = toSource_default(Map_default), promiseCtorString = toSource_default(Promise_default), setCtorString = toSource_default(Set_default), weakMapCtorString = toSource_default(WeakMap_default), getTag = baseGetTag_default;
+(DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) && (getTag = function(value) {
+  var result = baseGetTag_default(value), Ctor = result == objectTag3 ? value.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : "";
+  if (ctorString)
+    switch (ctorString) {
+      case dataViewCtorString:
+        return dataViewTag2;
+      case mapCtorString:
+        return mapTag2;
+      case promiseCtorString:
+        return promiseTag;
+      case setCtorString:
+        return setTag2;
+      case weakMapCtorString:
+        return weakMapTag2;
+    }
+  return result;
+});
+var getTag_default = getTag;
+
+// ../../node_modules/lodash-es/_initCloneArray.js
+var objectProto14 = Object.prototype, hasOwnProperty11 = objectProto14.hasOwnProperty;
+function initCloneArray(array) {
+  var length = array.length, result = new array.constructor(length);
+  return length && typeof array[0] == "string" && hasOwnProperty11.call(array, "index") && (result.index = array.index, result.input = array.input), result;
+}
+var initCloneArray_default = initCloneArray;
+
+// ../../node_modules/lodash-es/_Uint8Array.js
+var Uint8Array2 = root_default.Uint8Array, Uint8Array_default = Uint8Array2;
+
+// ../../node_modules/lodash-es/_cloneArrayBuffer.js
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  return new Uint8Array_default(result).set(new Uint8Array_default(arrayBuffer)), result;
+}
+var cloneArrayBuffer_default = cloneArrayBuffer;
+
+// ../../node_modules/lodash-es/_cloneDataView.js
+function cloneDataView(dataView, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer;
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var cloneDataView_default = cloneDataView;
+
+// ../../node_modules/lodash-es/_cloneRegExp.js
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  return result.lastIndex = regexp.lastIndex, result;
+}
+var cloneRegExp_default = cloneRegExp;
+
+// ../../node_modules/lodash-es/_cloneSymbol.js
+var symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0, symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+var cloneSymbol_default = cloneSymbol;
+
+// ../../node_modules/lodash-es/_cloneTypedArray.js
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = isDeep ? cloneArrayBuffer_default(typedArray.buffer) : typedArray.buffer;
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var cloneTypedArray_default = cloneTypedArray;
+
+// ../../node_modules/lodash-es/_initCloneByTag.js
+var boolTag2 = "[object Boolean]", dateTag2 = "[object Date]", mapTag3 = "[object Map]", numberTag2 = "[object Number]", regexpTag2 = "[object RegExp]", setTag3 = "[object Set]", stringTag2 = "[object String]", symbolTag2 = "[object Symbol]", arrayBufferTag2 = "[object ArrayBuffer]", dataViewTag3 = "[object DataView]", float32Tag2 = "[object Float32Array]", float64Tag2 = "[object Float64Array]", int8Tag2 = "[object Int8Array]", int16Tag2 = "[object Int16Array]", int32Tag2 = "[object Int32Array]", uint8Tag2 = "[object Uint8Array]", uint8ClampedTag2 = "[object Uint8ClampedArray]", uint16Tag2 = "[object Uint16Array]", uint32Tag2 = "[object Uint32Array]";
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag2:
+      return cloneArrayBuffer_default(object);
+    case boolTag2:
+    case dateTag2:
+      return new Ctor(+object);
+    case dataViewTag3:
+      return cloneDataView_default(object, isDeep);
+    case float32Tag2:
+    case float64Tag2:
+    case int8Tag2:
+    case int16Tag2:
+    case int32Tag2:
+    case uint8Tag2:
+    case uint8ClampedTag2:
+    case uint16Tag2:
+    case uint32Tag2:
+      return cloneTypedArray_default(object, isDeep);
+    case mapTag3:
+      return new Ctor();
+    case numberTag2:
+    case stringTag2:
+      return new Ctor(object);
+    case regexpTag2:
+      return cloneRegExp_default(object);
+    case setTag3:
+      return new Ctor();
+    case symbolTag2:
+      return cloneSymbol_default(object);
+  }
+}
+var initCloneByTag_default = initCloneByTag;
+
+// ../../node_modules/lodash-es/_initCloneObject.js
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype_default(object) ? baseCreate_default(getPrototype_default(object)) : {};
+}
+var initCloneObject_default = initCloneObject;
+
+// ../../node_modules/lodash-es/_baseIsMap.js
+var mapTag4 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike_default(value) && getTag_default(value) == mapTag4;
+}
+var baseIsMap_default = baseIsMap;
+
+// ../../node_modules/lodash-es/isMap.js
+var nodeIsMap = nodeUtil_default && nodeUtil_default.isMap, isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default, isMap_default = isMap;
+
+// ../../node_modules/lodash-es/_baseIsSet.js
+var setTag4 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike_default(value) && getTag_default(value) == setTag4;
+}
+var baseIsSet_default = baseIsSet;
+
+// ../../node_modules/lodash-es/isSet.js
+var nodeIsSet = nodeUtil_default && nodeUtil_default.isSet, isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default, isSet_default = isSet;
+
+// ../../node_modules/lodash-es/_baseClone.js
+var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4, argsTag3 = "[object Arguments]", arrayTag2 = "[object Array]", boolTag3 = "[object Boolean]", dateTag3 = "[object Date]", errorTag2 = "[object Error]", funcTag3 = "[object Function]", genTag2 = "[object GeneratorFunction]", mapTag5 = "[object Map]", numberTag3 = "[object Number]", objectTag4 = "[object Object]", regexpTag3 = "[object RegExp]", setTag5 = "[object Set]", stringTag3 = "[object String]", symbolTag3 = "[object Symbol]", weakMapTag3 = "[object WeakMap]", arrayBufferTag3 = "[object ArrayBuffer]", dataViewTag4 = "[object DataView]", float32Tag3 = "[object Float32Array]", float64Tag3 = "[object Float64Array]", int8Tag3 = "[object Int8Array]", int16Tag3 = "[object Int16Array]", int32Tag3 = "[object Int32Array]", uint8Tag3 = "[object Uint8Array]", uint8ClampedTag3 = "[object Uint8ClampedArray]", uint16Tag3 = "[object Uint16Array]", uint32Tag3 = "[object Uint32Array]", cloneableTags = {};
+cloneableTags[argsTag3] = cloneableTags[arrayTag2] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag3] = cloneableTags[float64Tag3] = cloneableTags[int8Tag3] = cloneableTags[int16Tag3] = cloneableTags[int32Tag3] = cloneableTags[mapTag5] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag5] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag3] = cloneableTags[uint8ClampedTag3] = cloneableTags[uint16Tag3] = cloneableTags[uint32Tag3] = !0;
+cloneableTags[errorTag2] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = !1;
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG;
+  if (customizer && (result = object ? customizer(value, key, object, stack) : customizer(value)), result !== void 0)
+    return result;
+  if (!isObject_default(value))
+    return value;
+  var isArr = isArray_default(value);
+  if (isArr) {
+    if (result = initCloneArray_default(value), !isDeep)
+      return copyArray_default(value, result);
+  } else {
+    var tag = getTag_default(value), isFunc = tag == funcTag3 || tag == genTag2;
+    if (isBuffer_default(value))
+      return cloneBuffer_default(value, isDeep);
+    if (tag == objectTag4 || tag == argsTag3 || isFunc && !object) {
+      if (result = isFlat || isFunc ? {} : initCloneObject_default(value), !isDeep)
+        return isFlat ? copySymbolsIn_default(value, baseAssignIn_default(result, value)) : copySymbols_default(value, baseAssign_default(result, value));
+    } else {
+      if (!cloneableTags[tag])
+        return object ? value : {};
+      result = initCloneByTag_default(value, tag, isDeep);
+    }
+  }
+  stack || (stack = new Stack_default());
+  var stacked = stack.get(value);
+  if (stacked)
+    return stacked;
+  stack.set(value, result), isSet_default(value) ? value.forEach(function(subValue) {
+    result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+  }) : isMap_default(value) && value.forEach(function(subValue, key2) {
+    result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  var keysFunc = isFull ? isFlat ? getAllKeysIn_default : getAllKeys_default : isFlat ? keysIn_default : keys_default, props = isArr ? void 0 : keysFunc(value);
+  return arrayEach_default(props || value, function(subValue, key2) {
+    props && (key2 = subValue, subValue = value[key2]), assignValue_default(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  }), result;
+}
+var baseClone_default = baseClone;
+
+// ../../node_modules/lodash-es/cloneDeep.js
+var CLONE_DEEP_FLAG2 = 1, CLONE_SYMBOLS_FLAG2 = 4;
+function cloneDeep(value) {
+  return baseClone_default(value, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG2);
+}
+var cloneDeep_default = cloneDeep;
+
+// ../../node_modules/lodash-es/_setCacheAdd.js
+var HASH_UNDEFINED3 = "__lodash_hash_undefined__";
+function setCacheAdd(value) {
+  return this.__data__.set(value, HASH_UNDEFINED3), 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;
+  for (this.__data__ = new MapCache_default(); ++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) {
+  for (var index = -1, length = array == null ? 0 : array.length; ++index < length; )
+    if (predicate(array[index], index, array))
+      return !0;
+  return !1;
+}
+var arraySome_default = arraySome;
+
+// ../../node_modules/lodash-es/_cacheHas.js
+function cacheHas(cache2, key) {
+  return cache2.has(key);
+}
+var cacheHas_default = cacheHas;
+
+// ../../node_modules/lodash-es/_equalArrays.js
+var COMPARE_PARTIAL_FLAG = 1, 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 !1;
+  var arrStacked = stack.get(array), othStacked = stack.get(other);
+  if (arrStacked && othStacked)
+    return arrStacked == other && othStacked == array;
+  var index = -1, result = !0, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0;
+  for (stack.set(array, other), stack.set(other, array); ++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 = !1;
+      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 = !1;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = !1;
+      break;
+    }
+  }
+  return stack.delete(array), stack.delete(other), result;
+}
+var equalArrays_default = equalArrays;
+
+// ../../node_modules/lodash-es/_mapToArray.js
+function mapToArray(map) {
+  var index = -1, result = Array(map.size);
+  return map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  }), result;
+}
+var mapToArray_default = mapToArray;
+
+// ../../node_modules/lodash-es/_setToArray.js
+function setToArray(set2) {
+  var index = -1, result = Array(set2.size);
+  return set2.forEach(function(value) {
+    result[++index] = value;
+  }), result;
+}
+var setToArray_default = setToArray;
+
+// ../../node_modules/lodash-es/_equalByTag.js
+var COMPARE_PARTIAL_FLAG2 = 1, COMPARE_UNORDERED_FLAG2 = 2, boolTag4 = "[object Boolean]", dateTag4 = "[object Date]", errorTag3 = "[object Error]", mapTag6 = "[object Map]", numberTag4 = "[object Number]", regexpTag4 = "[object RegExp]", setTag6 = "[object Set]", stringTag4 = "[object String]", symbolTag4 = "[object Symbol]", arrayBufferTag4 = "[object ArrayBuffer]", dataViewTag5 = "[object DataView]", symbolProto3 = Symbol_default ? Symbol_default.prototype : void 0, symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0;
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag5:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset)
+        return !1;
+      object = object.buffer, other = other.buffer;
+    case arrayBufferTag4:
+      return !(object.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object), new Uint8Array_default(other)));
+    case boolTag4:
+    case dateTag4:
+    case numberTag4:
+      return eq_default(+object, +other);
+    case errorTag3:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag4:
+    case stringTag4:
+      return object == other + "";
+    case mapTag6:
+      var convert = mapToArray_default;
+    case setTag6:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG2;
+      if (convert || (convert = setToArray_default), object.size != other.size && !isPartial)
+        return !1;
+      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);
+      return stack.delete(object), result;
+    case symbolTag4:
+      if (symbolValueOf2)
+        return symbolValueOf2.call(object) == symbolValueOf2.call(other);
+  }
+  return !1;
+}
+var equalByTag_default = equalByTag;
+
+// ../../node_modules/lodash-es/_equalObjects.js
+var COMPARE_PARTIAL_FLAG3 = 1, objectProto15 = Object.prototype, hasOwnProperty12 = objectProto15.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 !1;
+  for (var index = objLength; index--; ) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty12.call(other, key)))
+      return !1;
+  }
+  var objStacked = stack.get(object), othStacked = stack.get(other);
+  if (objStacked && othStacked)
+    return objStacked == other && othStacked == object;
+  var result = !0;
+  stack.set(object, other), stack.set(other, object);
+  for (var skipCtor = isPartial; ++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 = !1;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    objCtor != othCtor && "constructor" in object && "constructor" in other && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor) && (result = !1);
+  }
+  return stack.delete(object), stack.delete(other), result;
+}
+var equalObjects_default = equalObjects;
+
+// ../../node_modules/lodash-es/_baseIsEqualDeep.js
+var COMPARE_PARTIAL_FLAG4 = 1, argsTag4 = "[object Arguments]", arrayTag3 = "[object Array]", objectTag5 = "[object Object]", objectProto16 = Object.prototype, hasOwnProperty13 = objectProto16.hasOwnProperty;
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray_default(object), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag3 : getTag_default(object), othTag = othIsArr ? arrayTag3 : getTag_default(other);
+  objTag = objTag == argsTag4 ? objectTag5 : objTag, othTag = othTag == argsTag4 ? objectTag5 : othTag;
+  var objIsObj = objTag == objectTag5, othIsObj = othTag == objectTag5, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer_default(object)) {
+    if (!isBuffer_default(other))
+      return !1;
+    objIsArr = !0, objIsObj = !1;
+  }
+  if (isSameTag && !objIsObj)
+    return stack || (stack = new Stack_default()), 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 && hasOwnProperty13.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty13.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      return stack || (stack = new Stack_default()), equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  return isSameTag ? (stack || (stack = new Stack_default()), equalObjects_default(object, other, bitmask, customizer, equalFunc, stack)) : !1;
+}
+var baseIsEqualDeep_default = baseIsEqualDeep;
+
+// ../../node_modules/lodash-es/_baseIsEqual.js
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+  return value === other ? !0 : value == null || other == null || !isObjectLike_default(value) && !isObjectLike_default(other) ? value !== value && other !== other : baseIsEqualDeep_default(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+var baseIsEqual_default = baseIsEqual;
+
+// ../../node_modules/lodash-es/_baseIsMatch.js
+var COMPARE_PARTIAL_FLAG5 = 1, COMPARE_UNORDERED_FLAG3 = 2;
+function baseIsMatch(object, source, matchData, customizer) {
+  var index = matchData.length, length = index, noCustomizer = !customizer;
+  if (object == null)
+    return !length;
+  for (object = Object(object); index--; ) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object))
+      return !1;
+  }
+  for (; ++index < length; ) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (noCustomizer && data[2]) {
+      if (objValue === void 0 && !(key in object))
+        return !1;
+    } else {
+      var stack = new Stack_default();
+      if (customizer)
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      if (!(result === void 0 ? baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result))
+        return !1;
+    }
+  }
+  return !0;
+}
+var baseIsMatch_default = baseIsMatch;
+
+// ../../node_modules/lodash-es/_isStrictComparable.js
+function isStrictComparable(value) {
+  return value === value && !isObject_default(value);
+}
+var isStrictComparable_default = isStrictComparable;
+
+// ../../node_modules/lodash-es/_getMatchData.js
+function getMatchData(object) {
+  for (var result = keys_default(object), length = result.length; length--; ) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable_default(value)];
+  }
+  return result;
+}
+var getMatchData_default = getMatchData;
+
+// ../../node_modules/lodash-es/_matchesStrictComparable.js
+function matchesStrictComparable(key, srcValue) {
+  return function(object) {
+    return object == null ? !1 : object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+var matchesStrictComparable_default = matchesStrictComparable;
+
+// ../../node_modules/lodash-es/_baseMatches.js
+function baseMatches(source) {
+  var matchData = getMatchData_default(source);
+  return matchData.length == 1 && matchData[0][2] ? matchesStrictComparable_default(matchData[0][0], matchData[0][1]) : function(object) {
+    return object === source || baseIsMatch_default(object, source, matchData);
+  };
+}
+var baseMatches_default = baseMatches;
+
+// ../../node_modules/lodash-es/_baseHasIn.js
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+var baseHasIn_default = baseHasIn;
+
+// ../../node_modules/lodash-es/_hasPath.js
+function hasPath(object, path, hasFunc) {
+  path = castPath_default(path, object);
+  for (var index = -1, length = path.length, result = !1; ++index < length; ) {
+    var key = toKey_default(path[index]);
+    if (!(result = object != null && hasFunc(object, key)))
+      break;
+    object = object[key];
+  }
+  return result || ++index != length ? result : (length = object == null ? 0 : object.length, !!length && isLength_default(length) && isIndex_default(key, length) && (isArray_default(object) || isArguments_default(object)));
+}
+var hasPath_default = hasPath;
+
+// ../../node_modules/lodash-es/hasIn.js
+function hasIn(object, path) {
+  return object != null && hasPath_default(object, path, baseHasIn_default);
+}
+var hasIn_default = hasIn;
+
+// ../../node_modules/lodash-es/_baseMatchesProperty.js
+var COMPARE_PARTIAL_FLAG6 = 1, COMPARE_UNORDERED_FLAG4 = 2;
+function baseMatchesProperty(path, srcValue) {
+  return isKey_default(path) && isStrictComparable_default(srcValue) ? matchesStrictComparable_default(toKey_default(path), srcValue) : function(object) {
+    var objValue = get_default(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+  };
+}
+var baseMatchesProperty_default = baseMatchesProperty;
+
+// ../../node_modules/lodash-es/_baseProperty.js
+function baseProperty(key) {
+  return function(object) {
+    return object == null ? void 0 : object[key];
+  };
+}
+var baseProperty_default = baseProperty;
+
+// ../../node_modules/lodash-es/_basePropertyDeep.js
+function basePropertyDeep(path) {
+  return function(object) {
+    return baseGet_default(object, path);
+  };
+}
+var basePropertyDeep_default = basePropertyDeep;
+
+// ../../node_modules/lodash-es/property.js
+function property(path) {
+  return isKey_default(path) ? baseProperty_default(toKey_default(path)) : basePropertyDeep_default(path);
+}
+var property_default = property;
+
+// ../../node_modules/lodash-es/_baseIteratee.js
+function baseIteratee(value) {
+  return typeof value == "function" ? value : value == null ? identity_default : typeof value == "object" ? isArray_default(value) ? baseMatchesProperty_default(value[0], value[1]) : baseMatches_default(value) : property_default(value);
+}
+var baseIteratee_default = baseIteratee;
+
+// ../../node_modules/lodash-es/_createBaseFor.js
+function createBaseFor(fromRight) {
+  return function(object, iteratee, keysFunc) {
+    for (var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length; length--; ) {
+      var key = props[fromRight ? length : ++index];
+      if (iteratee(iterable[key], key, iterable) === !1)
+        break;
+    }
+    return object;
+  };
+}
+var createBaseFor_default = createBaseFor;
+
+// ../../node_modules/lodash-es/_baseFor.js
+var baseFor = createBaseFor_default(), baseFor_default = baseFor;
+
+// ../../node_modules/lodash-es/_baseForOwn.js
+function baseForOwn(object, iteratee) {
+  return object && baseFor_default(object, iteratee, keys_default);
+}
+var baseForOwn_default = baseForOwn;
+
+// ../../node_modules/lodash-es/now.js
+var now = function() {
+  return root_default.Date.now();
+}, now_default = now;
+
+// ../../node_modules/lodash-es/debounce.js
+var FUNC_ERROR_TEXT2 = "Expected a function", nativeMax = Math.max, nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = !1, maxing = !1, trailing = !0;
+  if (typeof func != "function")
+    throw new TypeError(FUNC_ERROR_TEXT2);
+  wait = toNumber_default(wait) || 0, isObject_default(options) && (leading = !!options.leading, maxing = "maxWait" in options, maxWait = maxing ? nativeMax(toNumber_default(options.maxWait) || 0, wait) : maxWait, trailing = "trailing" in options ? !!options.trailing : trailing);
+  function invokeFunc(time) {
+    var args = lastArgs, thisArg = lastThis;
+    return lastArgs = lastThis = void 0, lastInvokeTime = time, result = func.apply(thisArg, args), result;
+  }
+  function leadingEdge(time) {
+    return lastInvokeTime = time, timerId = setTimeout(timerExpired, wait), leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now_default();
+    if (shouldInvoke(time))
+      return trailingEdge(time);
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    return timerId = void 0, trailing && lastArgs ? invokeFunc(time) : (lastArgs = lastThis = void 0, result);
+  }
+  function cancel() {
+    timerId !== void 0 && clearTimeout(timerId), lastInvokeTime = 0, lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(now_default());
+  }
+  function debounced() {
+    var time = now_default(), isInvoking = shouldInvoke(time);
+    if (lastArgs = arguments, lastThis = this, lastCallTime = time, isInvoking) {
+      if (timerId === void 0)
+        return leadingEdge(lastCallTime);
+      if (maxing)
+        return clearTimeout(timerId), timerId = setTimeout(timerExpired, wait), invokeFunc(lastCallTime);
+    }
+    return timerId === void 0 && (timerId = setTimeout(timerExpired, wait)), result;
+  }
+  return debounced.cancel = cancel, debounced.flush = flush, debounced;
+}
+var debounce_default = debounce;
+
+// ../../node_modules/lodash-es/last.js
+function last(array) {
+  var length = array == null ? 0 : array.length;
+  return length ? array[length - 1] : void 0;
+}
+var last_default = last;
+
+// ../../node_modules/lodash-es/_parent.js
+function parent(object, path) {
+  return path.length < 2 ? object : baseGet_default(object, baseSlice_default(path, 0, -1));
+}
+var parent_default = parent;
+
+// ../../node_modules/lodash-es/isInteger.js
+function isInteger(value) {
+  return typeof value == "number" && value == toInteger_default(value);
+}
+var isInteger_default = isInteger;
+
+// ../../node_modules/lodash-es/mapValues.js
+function mapValues(object, iteratee) {
+  var result = {};
+  return iteratee = baseIteratee_default(iteratee, 3), baseForOwn_default(object, function(value, key, object2) {
+    baseAssignValue_default(result, key, iteratee(value, key, object2));
+  }), result;
+}
+var mapValues_default = mapValues;
+
+// ../../node_modules/lodash-es/_baseUnset.js
+function baseUnset(object, path) {
+  return path = castPath_default(path, object), object = parent_default(object, path), object == null || delete object[toKey_default(last_default(path))];
+}
+var baseUnset_default = baseUnset;
+
+// ../../node_modules/lodash-es/_baseRepeat.js
+var MAX_SAFE_INTEGER3 = 9007199254740991, nativeFloor = Math.floor;
+function baseRepeat(string2, n) {
+  var result = "";
+  if (!string2 || n < 1 || n > MAX_SAFE_INTEGER3)
+    return result;
+  do
+    n % 2 && (result += string2), n = nativeFloor(n / 2), n && (string2 += string2);
+  while (n);
+  return result;
+}
+var baseRepeat_default = baseRepeat;
+
+// ../../node_modules/lodash-es/_asciiSize.js
+var asciiSize = baseProperty_default("length"), asciiSize_default = asciiSize;
+
+// ../../node_modules/lodash-es/_unicodeSize.js
+var rsAstralRange3 = "\\ud800-\\udfff", rsComboMarksRange3 = "\\u0300-\\u036f", reComboHalfMarksRange3 = "\\ufe20-\\ufe2f", rsComboSymbolsRange3 = "\\u20d0-\\u20ff", rsComboRange3 = rsComboMarksRange3 + reComboHalfMarksRange3 + rsComboSymbolsRange3, rsVarRange3 = "\\ufe0e\\ufe0f", rsAstral2 = "[" + rsAstralRange3 + "]", rsCombo2 = "[" + rsComboRange3 + "]", rsFitz2 = "\\ud83c[\\udffb-\\udfff]", rsModifier2 = "(?:" + rsCombo2 + "|" + rsFitz2 + ")", rsNonAstral2 = "[^" + rsAstralRange3 + "]", rsRegional2 = "(?:\\ud83c[\\udde6-\\uddff]){2}", rsSurrPair2 = "[\\ud800-\\udbff][\\udc00-\\udfff]", rsZWJ3 = "\\u200d", reOptMod2 = rsModifier2 + "?", rsOptVar2 = "[" + rsVarRange3 + "]?", rsOptJoin2 = "(?:" + rsZWJ3 + "(?:" + [rsNonAstral2, rsRegional2, rsSurrPair2].join("|") + ")" + rsOptVar2 + reOptMod2 + ")*", rsSeq2 = rsOptVar2 + reOptMod2 + rsOptJoin2, rsSymbol2 = "(?:" + [rsNonAstral2 + rsCombo2 + "?", rsCombo2, rsRegional2, rsSurrPair2, rsAstral2].join("|") + ")", reUnicode2 = RegExp(rsFitz2 + "(?=" + rsFitz2 + ")|" + rsSymbol2 + rsSeq2, "g");
+function unicodeSize(string2) {
+  for (var result = reUnicode2.lastIndex = 0; reUnicode2.test(string2); )
+    ++result;
+  return result;
+}
+var unicodeSize_default = unicodeSize;
+
+// ../../node_modules/lodash-es/_stringSize.js
+function stringSize(string2) {
+  return hasUnicode_default(string2) ? unicodeSize_default(string2) : asciiSize_default(string2);
+}
+var stringSize_default = stringSize;
+
+// ../../node_modules/lodash-es/_createPadding.js
+var nativeCeil = Math.ceil;
+function createPadding(length, chars) {
+  chars = chars === void 0 ? " " : baseToString_default(chars);
+  var charsLength = chars.length;
+  if (charsLength < 2)
+    return charsLength ? baseRepeat_default(chars, length) : chars;
+  var result = baseRepeat_default(chars, nativeCeil(length / stringSize_default(chars)));
+  return hasUnicode_default(chars) ? castSlice_default(stringToArray_default(result), 0, length).join("") : result.slice(0, length);
+}
+var createPadding_default = createPadding;
+
+// ../../node_modules/lodash-es/padStart.js
+function padStart(string2, length, chars) {
+  string2 = toString_default(string2), length = toInteger_default(length);
+  var strLength = length ? stringSize_default(string2) : 0;
+  return length && strLength < length ? createPadding_default(length - strLength, chars) + string2 : string2;
+}
+var padStart_default = padStart;
+
+// ../../node_modules/lodash-es/unset.js
+function unset(object, path) {
+  return object == null ? !0 : baseUnset_default(object, path);
+}
+var unset_default = unset;
+
+// src/utils/keyframeUtils.ts
+var getSortedKeyframes = (keyframes) => {
+  let sorted = Object.values(
+    keyframes.byId
+  );
+  return sorted.sort((a, b) => a.position - b.position), cloneDeep_default(sorted);
+}, getSortedKeyframesCached = (0, import_memoizeFn.default)(getSortedKeyframes), fromArray = (keyframes) => {
+  let byId = {}, allIds = {};
+  for (let keyframe of keyframes)
+    byId[keyframe.id] = keyframe, allIds[keyframe.id] = !0;
+  return cloneDeep_default({ byId, allIds });
+}, fromSortedKeyframesCached = (0, import_memoizeFn.default)(fromArray);
+
+// src/sequences/interpolationTripleAtPosition.ts
+function interpolationTripleAtPosition(trackP, timeD) {
+  return (0, import_dataverse2.prism)(() => {
+    let track = (0, import_dataverse2.val)(trackP);
+    return import_dataverse2.prism.memo(
+      "driver",
+      () => track ? track.type === "BasicKeyframedTrack" ? _forKeyframedTrack(track, timeD) : (console.error("Track type not yet supported."), (0, import_dataverse2.prism)(() => {
+      })) : (0, import_dataverse2.prism)(() => {
+      }),
+      [track]
+    ).getValue();
+  });
+}
+function _forKeyframedTrack(track, timeD) {
+  return (0, import_dataverse2.prism)(() => {
+    let stateRef = import_dataverse2.prism.ref("state", { started: !1 }), state = stateRef.current, time = timeD.getValue();
+    return (!state.started || time < state.validFrom || state.validTo <= time) && (stateRef.current = state = updateState(timeD, track)), state.der.getValue();
+  });
+}
+var undefinedConstD = (0, import_dataverse2.prism)(() => {
+});
+function updateState(progressionD, track) {
+  let keyframes = getSortedKeyframesCached(track.keyframes), progression = progressionD.getValue();
+  if (keyframes.length === 0)
+    return {
+      started: !0,
+      validFrom: -1 / 0,
+      validTo: 1 / 0,
+      der: undefinedConstD
+    };
+  let currentKeyframeIndex = 0;
+  for (; ; ) {
+    let currentKeyframe = keyframes[currentKeyframeIndex];
+    if (!currentKeyframe)
+      return states.error;
+    let isLastKeyframe = currentKeyframeIndex === keyframes.length - 1;
+    if (progression < currentKeyframe.position)
+      return currentKeyframeIndex === 0 ? states.beforeFirstKeyframe(currentKeyframe) : states.error;
+    if (currentKeyframe.position === progression)
+      return isLastKeyframe ? states.lastKeyframe(currentKeyframe) : states.between(
+        currentKeyframe,
+        keyframes[currentKeyframeIndex + 1],
+        progressionD
+      );
+    if (currentKeyframeIndex === keyframes.length - 1)
+      return states.lastKeyframe(currentKeyframe);
+    {
+      let nextKeyframeIndex = currentKeyframeIndex + 1;
+      if (keyframes[nextKeyframeIndex].position <= progression) {
+        currentKeyframeIndex = nextKeyframeIndex;
+        continue;
+      } else
+        return states.between(
+          currentKeyframe,
+          keyframes[currentKeyframeIndex + 1],
+          progressionD
+        );
+    }
+  }
+}
+var states = {
+  beforeFirstKeyframe(kf) {
+    return {
+      started: !0,
+      validFrom: -1 / 0,
+      validTo: kf.position,
+      der: (0, import_dataverse2.prism)(() => ({ left: kf.value, progression: 0 }))
+    };
+  },
+  lastKeyframe(kf) {
+    return {
+      started: !0,
+      validFrom: kf.position,
+      validTo: 1 / 0,
+      der: (0, import_dataverse2.prism)(() => ({ left: kf.value, progression: 0 }))
+    };
+  },
+  between(left, right, progressionD) {
+    if (!left.connectedRight)
+      return {
+        started: !0,
+        validFrom: left.position,
+        validTo: right.position,
+        der: (0, import_dataverse2.prism)(() => ({ left: left.value, progression: 0 }))
+      };
+    let globalProgressionToLocalProgression = (globalProgression) => (globalProgression - left.position) / (right.position - left.position);
+    if (!left.type || left.type === "bezier") {
+      let solver = new import_UnitBezier.default(
+        left.handles[2],
+        left.handles[3],
+        right.handles[0],
+        right.handles[1]
+      ), bezierDer = (0, import_dataverse2.prism)(() => {
+        let progression = globalProgressionToLocalProgression(
+          progressionD.getValue()
+        ), valueProgression = solver.solveSimple(progression);
+        return {
+          left: left.value,
+          right: right.value,
+          progression: valueProgression
+        };
+      });
+      return {
+        started: !0,
+        validFrom: left.position,
+        validTo: right.position,
+        der: bezierDer
+      };
+    }
+    let holdDer = (0, import_dataverse2.prism)(() => {
+      let progression = globalProgressionToLocalProgression(
+        progressionD.getValue()
+      ), valueProgression = Math.floor(progression);
+      return {
+        left: left.value,
+        right: right.value,
+        progression: valueProgression
+      };
+    });
+    return {
+      started: !0,
+      validFrom: left.position,
+      validTo: right.position,
+      der: holdDer
+    };
+  },
+  error: {
+    started: !0,
+    validFrom: -1 / 0,
+    validTo: 1 / 0,
+    der: undefinedConstD
+  }
+};
+
+// src/sheetObjects/SheetObject.ts
+var import_deepMergeWithCache = __toESM(require("@theatre/utils/deepMergeWithCache")), import_pointerDeep = __toESM(require("@theatre/utils/pointerDeep")), import_SimpleCache2 = __toESM(require("@theatre/utils/SimpleCache")), import_valToAtom = require("@theatre/utils/valToAtom"), import_dataverse4 = require("@theatre/dataverse");
+
+// src/sheetObjects/TheatreSheetObject.ts
+var import_SimpleCache = __toESM(require("@theatre/utils/SimpleCache")), import_dataverse3 = require("@theatre/dataverse");
+var KEEP_HOT_FOR_MS = 5 * 1e3, TheatreSheetObject = class {
+  /**
+   * @internal
+   */
+  constructor(internals) {
+    __publicField(this, "_cache", new import_SimpleCache.default());
+    /** @internal See https://linear.app/theatre/issue/P-217/if-objvalue-is-read-make-sure-its-derivation-remains-hot-for-a-while */
+    __publicField(this, "_keepHotUntapDebounce");
+    setPrivateAPI(this, internals);
+  }
+  get type() {
+    return "Theatre_SheetObject_PublicAPI";
+  }
+  get props() {
+    return privateAPI(this).propsP;
+  }
+  get sheet() {
+    return privateAPI(this).sheet.publicApi;
+  }
+  get project() {
+    return privateAPI(this).sheet.project.publicApi;
+  }
+  get address() {
+    return __spreadValues({}, privateAPI(this).address);
+  }
+  _valuesPrism() {
+    return this._cache.get("_valuesPrism", () => {
+      let sheetObject = privateAPI(this);
+      return (0, import_dataverse3.prism)(() => (0, import_dataverse3.val)(sheetObject.getValues().getValue()));
+    });
+  }
+  onValuesChange(fn, rafDriver) {
+    return onChange(this._valuesPrism(), fn, rafDriver);
+  }
+  // internal: Make the deviration keepHot if directly read
+  get value() {
+    let der = this._valuesPrism();
+    if (KEEP_HOT_FOR_MS != null) {
+      if (!der.isHot) {
+        this._keepHotUntapDebounce != null && this._keepHotUntapDebounce.flush();
+        let untap = der.keepHot();
+        this._keepHotUntapDebounce = debounce_default(() => {
+          untap(), this._keepHotUntapDebounce = void 0;
+        }, KEEP_HOT_FOR_MS);
+      }
+      this._keepHotUntapDebounce && this._keepHotUntapDebounce();
+    }
+    return der.getValue();
+  }
+  set initialValue(val9) {
+    privateAPI(this).setInitialValue(val9);
+  }
+};
+
+// src/propTypes/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  compoundHasSimpleDescendants: () => compoundHasSimpleDescendants,
+  forEachPropDeep: () => forEachPropDeep,
+  getPropConfigByPath: () => getPropConfigByPath,
+  isPropConfSequencable: () => isPropConfSequencable,
+  isPropConfigComposite: () => isPropConfigComposite,
+  iteratePropType: () => iteratePropType,
+  valueInProp: () => valueInProp
+});
+var import_memoizeFn2 = __toESM(require("@theatre/utils/memoizeFn"));
+function forEachPropDeep(m, fn, startingPath = []) {
+  if (typeof m == "object" && m) {
+    if (isImage(m) || isRGBA(m)) {
+      fn(m, startingPath);
+      return;
+    }
+    for (let [key, value] of Object.entries(m))
+      forEachPropDeep(value, fn, [...startingPath, key]);
+  } else {
+    if (m == null)
+      return;
+    fn(m, startingPath);
+  }
+}
+var isImage = (value) => typeof value == "object" && value !== null && Object.hasOwnProperty.call(value, "type") && // @ts-ignore
+value.type === "image" && Object.hasOwnProperty.call(value, "id") && // @ts-ignore
+typeof value.id == "string" && // @ts-ignore
+value.id !== "", isRGBA = (value) => typeof value == "object" && value !== null && Object.hasOwnProperty.call(value, "r") && Object.hasOwnProperty.call(value, "g") && Object.hasOwnProperty.call(value, "b") && Object.hasOwnProperty.call(value, "a") && // @ts-ignore
+typeof value.r == "number" && // @ts-ignore
+typeof value.g == "number" && // @ts-ignore
+typeof value.b == "number" && // @ts-ignore
+typeof value.a == "number";
+function isPropConfigComposite(c) {
+  return c.type === "compound" || c.type === "enum";
+}
+function getPropConfigByPath(parentConf, path) {
+  if (!parentConf)
+    return;
+  let [key, ...rest] = path;
+  if (key === void 0)
+    return parentConf;
+  if (!isPropConfigComposite(parentConf))
+    return;
+  let sub = parentConf.type === "enum" ? parentConf.cases[key] : parentConf.props[key];
+  return getPropConfigByPath(sub, rest);
+}
+function valueInProp(value, propConfig) {
+  let sanitizedVal = propConfig.deserializeAndSanitize(value);
+  return sanitizedVal === void 0 ? propConfig.default : sanitizedVal;
+}
+function isPropConfSequencable(conf) {
+  return !isPropConfigComposite(conf);
+}
+var compoundHasSimpleDescendants = (0, import_memoizeFn2.default)(
+  (conf) => {
+    if (conf.type === "enum")
+      throw new Error("Not implemented yet for enums");
+    for (let key in conf.props) {
+      let subConf = conf.props[key];
+      if (isPropConfigComposite(subConf)) {
+        if (compoundHasSimpleDescendants(subConf))
+          return !0;
+      } else
+        return !0;
+    }
+    return !1;
+  }
+);
+function* iteratePropType(conf, pathPrefix) {
+  if (conf.type === "compound")
+    for (let key in conf.props)
+      yield* __yieldStar(iteratePropType(conf.props[key], [
+        ...pathPrefix,
+        key
+      ]));
+  else {
+    if (conf.type === "enum")
+      throw new Error("Not implemented yet");
+    return yield { path: pathPrefix, conf };
+  }
+}
+
+// src/sheetObjects/SheetObject.ts
+var SheetObject = class {
+  constructor(sheet, template, nativeObject) {
+    this.sheet = sheet;
+    this.template = template;
+    this.nativeObject = nativeObject;
+    __publicField(this, "$$isPointerToPrismProvider", !0);
+    __publicField(this, "address");
+    __publicField(this, "publicApi");
+    __publicField(this, "_initialValue", new import_dataverse4.Atom({}));
+    __publicField(this, "_cache", new import_SimpleCache2.default());
+    this.address = __spreadProps(__spreadValues({}, template.address), {
+      sheetInstanceId: sheet.address.sheetInstanceId
+    }), this.publicApi = new TheatreSheetObject(this);
+  }
+  get type() {
+    return "Theatre_SheetObject";
+  }
+  getValues() {
+    return this._cache.get(
+      "getValues()",
+      () => (0, import_dataverse4.prism)(() => {
+        let defaults = (0, import_dataverse4.val)(this.template.getDefaultValues()), initial = (0, import_dataverse4.val)(this._initialValue.pointer), withInitialCache = import_dataverse4.prism.memo(
+          "withInitialCache",
+          () => /* @__PURE__ */ new WeakMap(),
+          []
+        ), withInitial = (0, import_deepMergeWithCache.default)(
+          defaults,
+          initial,
+          withInitialCache
+        ), statics = (0, import_dataverse4.val)(this.template.getStaticValues()), withStaticsCache = import_dataverse4.prism.memo(
+          "withStatics",
+          () => /* @__PURE__ */ new WeakMap(),
+          []
+        ), final = (0, import_deepMergeWithCache.default)(
+          withInitial,
+          statics,
+          withStaticsCache
+        ), sequenced;
+        {
+          let pointerToSequencedValuesD = import_dataverse4.prism.memo(
+            "seq",
+            () => this.getSequencedValues(),
+            []
+          ), withSeqsCache = import_dataverse4.prism.memo(
+            "withSeqsCache",
+            () => /* @__PURE__ */ new WeakMap(),
+            []
+          );
+          sequenced = (0, import_dataverse4.val)((0, import_dataverse4.val)(pointerToSequencedValuesD)), final = (0, import_deepMergeWithCache.default)(final, sequenced, withSeqsCache);
+        }
+        return (0, import_valToAtom.valToAtom)("finalAtom", final).pointer;
+      })
+    );
+  }
+  getValueByPointer(pointer3) {
+    let allValuesP = (0, import_dataverse4.val)(this.getValues()), { path } = (0, import_dataverse4.getPointerParts)(pointer3);
+    return (0, import_dataverse4.val)(
+      (0, import_pointerDeep.default)(allValuesP, path)
+    );
+  }
+  pointerToPrism(pointer3) {
+    let { path } = (0, import_dataverse4.getPointerParts)(pointer3);
+    return (0, import_dataverse4.prism)(() => {
+      let allValuesP = (0, import_dataverse4.val)(this.getValues());
+      return (0, import_dataverse4.val)((0, import_pointerDeep.default)(allValuesP, path));
+    });
+  }
+  /**
+   * Returns values of props that are sequenced.
+   */
+  getSequencedValues() {
+    return (0, import_dataverse4.prism)(() => {
+      let tracksToProcessD = import_dataverse4.prism.memo(
+        "tracksToProcess",
+        () => this.template.getArrayOfValidSequenceTracks(),
+        []
+      ), tracksToProcess = (0, import_dataverse4.val)(tracksToProcessD), valsAtom = new import_dataverse4.Atom({}), config = (0, import_dataverse4.val)(this.template.configPointer);
+      return import_dataverse4.prism.effect(
+        "processTracks",
+        () => {
+          let untaps = [];
+          for (let { trackId, pathToProp } of tracksToProcess) {
+            let pr = this._trackIdToPrism(trackId), propConfig = getPropConfigByPath(
+              config,
+              pathToProp
+            ), deserializeAndSanitize = propConfig.deserializeAndSanitize, interpolate = propConfig.interpolate, updateSequenceValueFromItsPrism = () => {
+              let triple = pr.getValue();
+              if (!triple)
+                return valsAtom.setByPointer(
+                  (p) => (0, import_pointerDeep.default)(p, pathToProp),
+                  void 0
+                );
+              let leftDeserialized = deserializeAndSanitize(triple.left), left = leftDeserialized === void 0 ? propConfig.default : leftDeserialized;
+              if (triple.right === void 0)
+                return valsAtom.setByPointer(
+                  (p) => (0, import_pointerDeep.default)(p, pathToProp),
+                  left
+                );
+              let rightDeserialized = deserializeAndSanitize(triple.right), right = rightDeserialized === void 0 ? propConfig.default : rightDeserialized;
+              return valsAtom.setByPointer(
+                (p) => (0, import_pointerDeep.default)(p, pathToProp),
+                interpolate(left, right, triple.progression)
+              );
+            }, untap = pr.onStale(updateSequenceValueFromItsPrism);
+            updateSequenceValueFromItsPrism(), untaps.push(untap);
+          }
+          return () => {
+            for (let untap of untaps)
+              untap();
+          };
+        },
+        [config, ...tracksToProcess]
+      ), valsAtom.pointer;
+    });
+  }
+  _trackIdToPrism(trackId) {
+    let trackP = this.template.project.pointers.historic.sheetsById[this.address.sheetId].sequence.tracksByObject[this.address.objectKey].trackData[trackId], timeD = this.sheet.getSequence().positionPrism;
+    return interpolationTripleAtPosition(trackP, timeD);
+  }
+  get propsP() {
+    return this._cache.get(
+      "propsP",
+      () => (0, import_dataverse4.pointer)({ root: this, path: [] })
+    );
+  }
+  validateValue(pointer3, value) {
+  }
+  setInitialValue(val9) {
+    this.validateValue(this.propsP, val9), this._initialValue.set(val9);
+  }
+};
+
+// src/sheetObjects/getOrderingOfPropTypeConfig.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function getOrderingOfPropTypeConfig(config) {
+  let existing = cache.get(config);
+  if (existing)
+    return existing;
+  let map = /* @__PURE__ */ new Map();
+  return cache.set(config, map), iterateOnCompound([], config, map), map;
+}
+function iterateOnCompound(path, config, map) {
+  for (let [key, subConf] of Object.entries(config.props))
+    if (!isPropConfigComposite(subConf)) {
+      let subPath = [...path, key];
+      map.set(JSON.stringify(subPath), map.size), iterateOnAny(subPath, subConf, map);
+    }
+  for (let [key, subConf] of Object.entries(config.props))
+    if (isPropConfigComposite(subConf)) {
+      let subPath = [...path, key];
+      map.set(JSON.stringify(subPath), map.size), iterateOnAny(subPath, subConf, map);
+    }
+}
+function iterateOnAny(path, config, map) {
+  if (config.type === "compound")
+    iterateOnCompound(path, config, map);
+  else {
+    if (config.type === "enum")
+      throw new Error("Enums aren't supported yet");
+    map.set(JSON.stringify(path), map.size);
+  }
+}
+
+// src/sheetObjects/SheetObjectTemplate.ts
+function isObjectEmpty(obj) {
+  return typeof obj == "object" && obj !== null && Object.keys(obj).length === 0;
+}
+var SheetObjectTemplate = class {
+  constructor(sheetTemplate, objectKey, nativeObject, config, _temp_actions) {
+    this.sheetTemplate = sheetTemplate;
+    __publicField(this, "address");
+    __publicField(this, "type", "Theatre_SheetObjectTemplate");
+    __publicField(this, "_config");
+    __publicField(this, "_temp_actions_atom");
+    __publicField(this, "_cache", new import_SimpleCache3.default());
+    __publicField(this, "project");
+    __publicField(this, "pointerToSheetState");
+    __publicField(this, "pointerToStaticOverrides");
+    this.address = __spreadProps(__spreadValues({}, sheetTemplate.address), { objectKey }), this._config = new import_dataverse5.Atom(config), this._temp_actions_atom = new import_dataverse5.Atom(_temp_actions), this.project = sheetTemplate.project, this.pointerToSheetState = this.sheetTemplate.project.pointers.historic.sheetsById[this.address.sheetId], this.pointerToStaticOverrides = this.pointerToSheetState.staticOverrides.byObject[this.address.objectKey];
+  }
+  get staticConfig() {
+    return this._config.get();
+  }
+  get configPointer() {
+    return this._config.pointer;
+  }
+  get _temp_actions() {
+    return this._temp_actions_atom.get();
+  }
+  get _temp_actionsPointer() {
+    return this._temp_actions_atom.pointer;
+  }
+  createInstance(sheet, nativeObject, config) {
+    return this._config.set(config), new SheetObject(sheet, this, nativeObject);
+  }
+  reconfigure(config) {
+    this._config.set(config);
+  }
+  /**
+   * The `actions` api is temporary until we implement events.
+   */
+  _temp_setActions(actions) {
+    this._temp_actions_atom.set(actions);
+  }
+  /**
+   * Returns the default values (all defaults are read from the config)
+   */
+  getDefaultValues() {
+    return this._cache.get(
+      "getDefaultValues()",
+      () => (0, import_dataverse5.prism)(() => {
+        let config = (0, import_dataverse5.val)(this.configPointer);
+        return getPropDefaultsOfSheetObject(config);
+      })
+    );
+  }
+  /**
+   * Returns values that are set statically (ie, not sequenced, and not defaults)
+   */
+  getStaticValues() {
+    return this._cache.get(
+      "getStaticValues",
+      () => (0, import_dataverse5.prism)(() => {
+        var _a;
+        let json = (_a = (0, import_dataverse5.val)(this.pointerToStaticOverrides)) != null ? _a : {};
+        return (0, import_dataverse5.val)(this.configPointer).deserializeAndSanitize(json) || {};
+      })
+    );
+  }
+  /**
+   * Filters through the sequenced tracks and returns those tracks who are valid
+   * according to the object's prop types, then sorted in the same order as the config
+   *
+   * Returns an array.
+   */
+  getArrayOfValidSequenceTracks() {
+    return this._cache.get(
+      "getArrayOfValidSequenceTracks",
+      () => (0, import_dataverse5.prism)(() => {
+        let pointerToSheetState = this.project.pointers.historic.sheetsById[this.address.sheetId], trackIdByPropPath = (0, import_dataverse5.val)(
+          pointerToSheetState.sequence.tracksByObject[this.address.objectKey].trackIdByPropPath
+        );
+        if (!trackIdByPropPath)
+          return import_utils3.emptyArray;
+        let arrayOfIds = [];
+        if (!trackIdByPropPath)
+          return import_utils3.emptyArray;
+        let objectConfig = (0, import_dataverse5.val)(this.configPointer), _entries = Object.entries(trackIdByPropPath);
+        for (let [pathToPropInString, trackId] of _entries) {
+          let pathToProp = parsePathToProp(pathToPropInString);
+          if (!pathToProp)
+            continue;
+          let propConfig = getPropConfigByPath(objectConfig, pathToProp);
+          propConfig && isPropConfSequencable(propConfig) && arrayOfIds.push({ pathToProp, trackId });
+        }
+        let mapping = getOrderingOfPropTypeConfig(objectConfig);
+        return arrayOfIds.sort((a, b) => {
+          let pathToPropA = a.pathToProp, pathToPropB = b.pathToProp, indexA = mapping.get(JSON.stringify(pathToPropA)), indexB = mapping.get(JSON.stringify(pathToPropB));
+          return indexA > indexB ? 1 : -1;
+        }), arrayOfIds.length === 0 ? import_utils3.emptyArray : arrayOfIds;
+      })
+    );
+  }
+  /**
+   * Filters through the sequenced tracks those tracks that are valid
+   * according to the object's prop types.
+   *
+   * Returns a map.
+   *
+   * Not available in core.
+   */
+  getMapOfValidSequenceTracks_forStudio() {
+    return this._cache.get(
+      "getMapOfValidSequenceTracks_forStudio",
+      () => (0, import_dataverse5.prism)(() => {
+        let arr = (0, import_dataverse5.val)(this.getArrayOfValidSequenceTracks()), map = {};
+        for (let { pathToProp, trackId } of arr)
+          set_default(map, pathToProp, trackId);
+        return map;
+      })
+    );
+  }
+  /**
+   * @returns The static overrides that are not sequenced. Returns undefined if there are no static overrides,
+   * or if all those static overrides are sequenced.
+   */
+  getStaticButNotSequencedOverrides() {
+    return this._cache.get(
+      "getStaticButNotSequencedOverrides",
+      () => (0, import_dataverse5.prism)(() => {
+        let staticOverrides = (0, import_dataverse5.val)(this.getStaticValues()), arrayOfValidSequenceTracks = (0, import_dataverse5.val)(
+          this.getArrayOfValidSequenceTracks()
+        ), staticButNotSequencedOverrides = cloneDeep_default(staticOverrides);
+        for (let { pathToProp } of arrayOfValidSequenceTracks) {
+          unset_default(staticButNotSequencedOverrides, pathToProp);
+          let parentPath = pathToProp.slice(0, -1);
+          for (; parentPath.length > 0; ) {
+            let parentValue = (0, import_getDeep.default)(
+              staticButNotSequencedOverrides,
+              parentPath
+            );
+            if (!isObjectEmpty(parentValue))
+              break;
+            unset_default(staticButNotSequencedOverrides, parentPath), parentPath = parentPath.slice(0, -1);
+          }
+        }
+        if (!isObjectEmpty(staticButNotSequencedOverrides))
+          return staticButNotSequencedOverrides;
+      })
+    );
+  }
+  getDefaultsAtPointer(pointer3) {
+    let { path } = (0, import_dataverse5.getPointerParts)(pointer3), defaults = this.getDefaultValues().getValue();
+    return (0, import_getDeep.default)(defaults, path);
+  }
+};
+function parsePathToProp(pathToPropInString) {
+  try {
+    return JSON.parse(pathToPropInString);
+  } catch (e) {
+    console.warn(
+      "property ".concat(JSON.stringify(
+        pathToPropInString
+      ), " cannot be parsed. Skipping.")
+    );
+    return;
+  }
+}
+
+// src/sheets/SheetTemplate.ts
+var import_dataverse14 = require("@theatre/dataverse");
+
+// src/sequences/Sequence.ts
+var import_pathToProp = require("@theatre/utils/pathToProp"), import_didYouMean = require("@theatre/utils/didYouMean"), import_errors2 = require("@theatre/utils/errors"), import_dataverse9 = require("@theatre/dataverse"), import_dataverse10 = require("@theatre/dataverse"), import_dataverse11 = require("@theatre/dataverse"), import_dataverse12 = require("@theatre/dataverse");
+
+// src/sequences/playbackControllers/DefaultPlaybackController.ts
+var import_defer = require("@theatre/utils/defer"), import_noop = __toESM(require("@theatre/utils/noop")), import_dataverse6 = require("@theatre/dataverse");
+var DefaultPlaybackController = class {
+  constructor() {
+    __publicField(this, "_stopPlayCallback", import_noop.default);
+    __publicField(this, "_state", new import_dataverse6.Atom({
+      position: 0,
+      playing: !1
+    }));
+    __publicField(this, "statePointer");
+    this.statePointer = this._state.pointer;
+  }
+  destroy() {
+  }
+  pause() {
+    this._stopPlayCallback(), this.playing = !1, this._stopPlayCallback = import_noop.default;
+  }
+  gotoPosition(time) {
+    this._updatePositionInState(time);
+  }
+  _updatePositionInState(time) {
+    this._state.setByPointer((p) => p.position, time);
+  }
+  getCurrentPosition() {
+    return this._state.get().position;
+  }
+  get playing() {
+    return this._state.get().playing;
+  }
+  set playing(playing) {
+    this._state.setByPointer((p) => p.playing, playing);
+  }
+  play(iterationCount, range, rate, direction, ticker) {
+    this.playing && this.pause(), this.playing = !0;
+    let iterationLength = range[1] - range[0];
+    {
+      let startPos = this.getCurrentPosition();
+      startPos < range[0] || startPos > range[1] ? direction === "normal" || direction === "alternate" ? this._updatePositionInState(range[0]) : (direction === "reverse" || direction === "alternateReverse") && this._updatePositionInState(range[1]) : direction === "normal" || direction === "alternate" ? startPos === range[1] && this._updatePositionInState(range[0]) : startPos === range[0] && this._updatePositionInState(range[1]);
+    }
+    let deferred = (0, import_defer.defer)(), initialTickerTime = ticker.time, totalPlaybackLength = iterationLength * iterationCount, initialElapsedPos = this.getCurrentPosition() - range[0];
+    (direction === "reverse" || direction === "alternateReverse") && (initialElapsedPos = range[1] - this.getCurrentPosition());
+    let tick = (currentTickerTime) => {
+      let elapsedTickerTimeInSeconds = Math.max(
+        currentTickerTime - initialTickerTime,
+        0
+      ) / 1e3, elapsedPos = Math.min(
+        elapsedTickerTimeInSeconds * rate + initialElapsedPos,
+        totalPlaybackLength
+      );
+      if (elapsedPos !== totalPlaybackLength) {
+        let iterationNumber = Math.floor(elapsedPos / iterationLength), currentIterationPos = elapsedPos / iterationLength % 1 * iterationLength;
+        if (direction !== "normal")
+          if (direction === "reverse")
+            currentIterationPos = iterationLength - currentIterationPos;
+          else {
+            let isCurrentIterationNumberEven = iterationNumber % 2 === 0;
+            direction === "alternate" ? isCurrentIterationNumberEven || (currentIterationPos = iterationLength - currentIterationPos) : isCurrentIterationNumberEven && (currentIterationPos = iterationLength - currentIterationPos);
+          }
+        this._updatePositionInState(currentIterationPos + range[0]), requestNextTick();
+      } else {
+        if (direction === "normal")
+          this._updatePositionInState(range[1]);
+        else if (direction === "reverse")
+          this._updatePositionInState(range[0]);
+        else {
+          let isLastIterationEven = (iterationCount - 1) % 2 === 0;
+          direction === "alternate" ? isLastIterationEven ? this._updatePositionInState(range[1]) : this._updatePositionInState(range[0]) : isLastIterationEven ? this._updatePositionInState(range[0]) : this._updatePositionInState(range[1]);
+        }
+        this.playing = !1, deferred.resolve(!0);
+      }
+    };
+    this._stopPlayCallback = () => {
+      ticker.offThisOrNextTick(tick), ticker.offNextTick(tick), this.playing && deferred.resolve(!1);
+    };
+    let requestNextTick = () => ticker.onNextTick(tick);
+    return ticker.onThisOrNextTick(tick), deferred.promise;
+  }
+  playDynamicRange(rangeD, ticker) {
+    this.playing && this.pause(), this.playing = !0;
+    let deferred = (0, import_defer.defer)(), untapFromRangeD = rangeD.keepHot();
+    deferred.promise.then(untapFromRangeD, untapFromRangeD);
+    let lastTickerTime = ticker.time, tick = (currentTickerTime) => {
+      let elapsedSinceLastTick = Math.max(
+        currentTickerTime - lastTickerTime,
+        0
+      );
+      lastTickerTime = currentTickerTime;
+      let elapsedSinceLastTickInSeconds = elapsedSinceLastTick / 1e3, lastPosition = this.getCurrentPosition(), range = rangeD.getValue();
+      if (lastPosition < range[0] || lastPosition > range[1])
+        this.gotoPosition(range[0]);
+      else {
+        let newPosition = lastPosition + elapsedSinceLastTickInSeconds;
+        newPosition > range[1] && (newPosition = range[0] + (newPosition - range[1])), this.gotoPosition(newPosition);
+      }
+      requestNextTick();
+    };
+    this._stopPlayCallback = () => {
+      ticker.offThisOrNextTick(tick), ticker.offNextTick(tick), deferred.resolve(!1);
+    };
+    let requestNextTick = () => ticker.onNextTick(tick);
+    return ticker.onThisOrNextTick(tick), deferred.promise;
+  }
+};
+
+// src/sequences/TheatreSequence.ts
+var import_defer3 = require("@theatre/utils/defer");
+
+// src/sequences/playbackControllers/AudioPlaybackController.ts
+var import_defer2 = require("@theatre/utils/defer"), import_errors = require("@theatre/utils/errors"), import_noop2 = __toESM(require("@theatre/utils/noop")), import_dataverse7 = require("@theatre/dataverse");
+
+// src/globals.ts
+var globals = {
+  /**
+   * If the schema of the redux store changes in a backwards-incompatible way, then this version number should be incremented.
+   *
+   * While this looks like semver, it is not. There are no patch numbers, so any change in this number is a breaking change.
+   *
+   * However, as long as the schema of the redux store is backwards-compatible, then we don't have to change this number.
+   *
+   * Since the 0.4.0 release, this number has not had to change.
+   */
+  currentProjectStateDefinitionVersion: "0.4.0"
+}, globalVariableNames = {
+  StudioBundle: "__TheatreJS_StudioBundle",
+  coreBundle: "__TheatreJS_CoreBundle",
+  notifications: "__TheatreJS_Notifications"
+};
+
+// src/utils/notify.ts
+var createHandler = (type) => (...args) => {
+  var _a;
+  switch (type) {
+    case "success":
+      break;
+    case "info": {
+      console.info(args.slice(0, 2).join("\n"));
+      break;
+    }
+    case "warning": {
+      console.warn(args.slice(0, 2).join("\n"));
+      break;
+    }
+    case "error":
+  }
+  return typeof window < "u" ? (
+    // @ts-ignore
+    (_a = window[globalVariableNames.notifications]) == null ? void 0 : _a.notify[type](...args)
+  ) : void 0;
+}, notify = {
+  warning: createHandler("warning"),
+  success: createHandler("success"),
+  info: createHandler("info"),
+  error: createHandler("error")
+};
+typeof window < "u" && (window.addEventListener("error", (e) => {
+  notify.error(
+    "An error occurred",
+    "<pre>".concat(e.message, "</pre>\n\nSee **console** for details.")
+  );
+}), window.addEventListener("unhandledrejection", (e) => {
+  notify.error(
+    "An error occurred",
+    "<pre>".concat(e.reason, "</pre>\n\nSee **console** for details.")
+  );
+}));
+
+// src/sequences/playbackControllers/AudioPlaybackController.ts
+var AudioPlaybackController = class {
+  constructor(_decodedBuffer, _audioContext, _nodeDestination) {
+    this._decodedBuffer = _decodedBuffer;
+    this._audioContext = _audioContext;
+    this._nodeDestination = _nodeDestination;
+    __publicField(this, "_mainGain");
+    __publicField(this, "_state", new import_dataverse7.Atom({
+      position: 0,
+      playing: !1
+    }));
+    __publicField(this, "statePointer");
+    __publicField(this, "_stopPlayCallback", import_noop2.default);
+    this.statePointer = this._state.pointer, this._mainGain = this._audioContext.createGain(), this._mainGain.connect(this._nodeDestination);
+  }
+  playDynamicRange(rangeD, ticker) {
+    let deferred = (0, import_defer2.defer)();
+    this._playing && this.pause(), this._playing = !0;
+    let stop, play = () => {
+      stop == null || stop(), stop = this._loopInRange(rangeD.getValue(), ticker).stop;
+    }, untapFromRangeD = rangeD.onStale(play);
+    return play(), this._stopPlayCallback = () => {
+      stop == null || stop(), untapFromRangeD(), deferred.resolve(!1);
+    }, deferred.promise;
+  }
+  _loopInRange(range, ticker) {
+    let startPos = this.getCurrentPosition(), iterationLength = range[1] - range[0];
+    startPos < range[0] || startPos > range[1] ? this._updatePositionInState(range[0]) : startPos === range[1] && this._updatePositionInState(range[0]), startPos = this.getCurrentPosition();
+    let currentSource = this._audioContext.createBufferSource();
+    currentSource.buffer = this._decodedBuffer, currentSource.connect(this._mainGain), currentSource.playbackRate.value = 1, currentSource.loop = !0, currentSource.loopStart = range[0], currentSource.loopEnd = range[1];
+    let initialTickerTime = ticker.time, initialElapsedPos = startPos - range[0];
+    currentSource.start(0, startPos);
+    let tick = (currentTickerTime) => {
+      let currentIterationPos = (Math.max(
+        currentTickerTime - initialTickerTime,
+        0
+      ) / 1e3 * 1 + initialElapsedPos) / iterationLength % 1 * iterationLength;
+      this._updatePositionInState(currentIterationPos + range[0]), requestNextTick();
+    }, requestNextTick = () => ticker.onNextTick(tick);
+    return ticker.onThisOrNextTick(tick), { stop: () => {
+      currentSource.stop(), currentSource.disconnect(), ticker.offThisOrNextTick(tick), ticker.offNextTick(tick);
+    } };
+  }
+  get _playing() {
+    return this._state.get().playing;
+  }
+  set _playing(playing) {
+    this._state.setByPointer((p) => p.playing, playing);
+  }
+  destroy() {
+  }
+  pause() {
+    this._stopPlayCallback(), this._playing = !1, this._stopPlayCallback = import_noop2.default;
+  }
+  gotoPosition(time) {
+    this._updatePositionInState(time);
+  }
+  _updatePositionInState(time) {
+    this._state.reduce((s) => __spreadProps(__spreadValues({}, s), { position: time }));
+  }
+  getCurrentPosition() {
+    return this._state.get().position;
+  }
+  play(iterationCount, range, rate, direction, ticker) {
+    this._playing && this.pause(), this._playing = !0;
+    let startPos = this.getCurrentPosition(), iterationLength = range[1] - range[0];
+    if (direction !== "normal")
+      throw new import_errors.InvalidArgumentError(
+        'Audio-controlled sequences can only be played in the "normal" direction. ' + "'".concat(direction, "' given.")
+      );
+    startPos < range[0] || startPos > range[1] ? this._updatePositionInState(range[0]) : startPos === range[1] && this._updatePositionInState(range[0]), startPos = this.getCurrentPosition();
+    let deferred = (0, import_defer2.defer)(), currentSource = this._audioContext.createBufferSource();
+    currentSource.buffer = this._decodedBuffer, currentSource.connect(this._mainGain), currentSource.playbackRate.value = rate, iterationCount > 1e3 && (notify.warning(
+      "Can't play sequences with audio more than 1000 times",
+      "The sequence will still play, but only 1000 times. The `iterationCount: ".concat(iterationCount, "` provided to `sequence.play()`\nis too high for a sequence with audio.\n\nTo fix this, either set `iterationCount` to a lower value, or remove the audio from the sequence."),
+      [
+        {
+          url: "https://www.theatrejs.com/docs/latest/manual/audio",
+          title: "Using Audio"
+        },
+        {
+          url: "https://www.theatrejs.com/docs/latest/api/core#sequence.attachaudio",
+          title: "Audio API"
+        }
+      ]
+    ), iterationCount = 1e3), iterationCount > 1 && (currentSource.loop = !0, currentSource.loopStart = range[0], currentSource.loopEnd = range[1]);
+    let initialTickerTime = ticker.time, initialElapsedPos = startPos - range[0], totalPlaybackLength = iterationLength * iterationCount;
+    currentSource.start(0, startPos, totalPlaybackLength - initialElapsedPos);
+    let tick = (currentTickerTime) => {
+      let elapsedTickerTimeInSeconds = Math.max(
+        currentTickerTime - initialTickerTime,
+        0
+      ) / 1e3, elapsedPos = Math.min(
+        elapsedTickerTimeInSeconds * rate + initialElapsedPos,
+        totalPlaybackLength
+      );
+      if (elapsedPos !== totalPlaybackLength) {
+        let currentIterationPos = elapsedPos / iterationLength % 1 * iterationLength;
+        this._updatePositionInState(currentIterationPos + range[0]), requestNextTick();
+      } else
+        this._updatePositionInState(range[1]), this._playing = !1, cleanup(), deferred.resolve(!0);
+    }, cleanup = () => {
+      currentSource.stop(), currentSource.disconnect();
+    };
+    this._stopPlayCallback = () => {
+      cleanup(), ticker.offThisOrNextTick(tick), ticker.offNextTick(tick), this._playing && deferred.resolve(!1);
+    };
+    let requestNextTick = () => ticker.onNextTick(tick);
+    return ticker.onThisOrNextTick(tick), deferred.promise;
+  }
+};
+
+// src/rafDrivers.ts
+var import_dataverse8 = require("@theatre/dataverse");
+var lastDriverId = 0;
+function createRafDriver(conf) {
+  var _a;
+  let tick = (time) => {
+    ticker.tick(time);
+  }, ticker = new import_dataverse8.Ticker({
+    onActive() {
+      var _a2;
+      (_a2 = conf == null ? void 0 : conf.start) == null || _a2.call(conf);
+    },
+    onDormant() {
+      var _a2;
+      (_a2 = conf == null ? void 0 : conf.stop) == null || _a2.call(conf);
+    }
+  }), driverPublicApi = {
+    tick,
+    id: lastDriverId++,
+    name: (_a = conf == null ? void 0 : conf.name) != null ? _a : "CustomRafDriver-".concat(lastDriverId),
+    type: "Theatre_RafDriver_PublicAPI"
+  }, driverPrivateApi = {
+    type: "Theatre_RafDriver_PrivateAPI",
+    publicApi: driverPublicApi,
+    ticker,
+    start: conf == null ? void 0 : conf.start,
+    stop: conf == null ? void 0 : conf.stop
+  };
+  return setPrivateAPI(driverPublicApi, driverPrivateApi), driverPublicApi;
+}
+
+// src/coreTicker.ts
+function createBasicRafDriver() {
+  let rafId = null, driver = createRafDriver({ name: "DefaultCoreRafDriver", start: () => {
+    if (typeof window < "u") {
+      let onAnimationFrame = (t) => {
+        driver.tick(t), rafId = window.requestAnimationFrame(onAnimationFrame);
+      };
+      rafId = window.requestAnimationFrame(onAnimationFrame);
+    } else
+      driver.tick(0), setTimeout(() => driver.tick(1), 0);
+  }, stop: () => {
+    typeof window < "u" && rafId !== null && window.cancelAnimationFrame(rafId);
+  } });
+  return driver;
+}
+var coreRafDriver;
+function getCoreRafDriver() {
+  return coreRafDriver || setCoreRafDriver(createBasicRafDriver()), coreRafDriver;
+}
+function getCoreTicker() {
+  return getCoreRafDriver().ticker;
+}
+function setCoreRafDriver(driver) {
+  if (coreRafDriver)
+    throw new Error("`setCoreRafDriver()` is already called.");
+  coreRafDriver = privateAPI(driver);
+}
+
+// src/sequences/TheatreSequence.ts
+var TheatreSequence = class {
+  get type() {
+    return "Theatre_Sequence_PublicAPI";
+  }
+  /**
+   * @internal
+   */
+  constructor(seq) {
+    setPrivateAPI(this, seq);
+  }
+  play(conf) {
+    let priv = privateAPI(this);
+    if (priv._project.isReady()) {
+      let ticker = conf != null && conf.rafDriver ? privateAPI(conf.rafDriver).ticker : getCoreTicker();
+      return priv.play(conf != null ? conf : {}, ticker);
+    } else {
+      let d = (0, import_defer3.defer)();
+      return d.resolve(!0), d.promise;
+    }
+  }
+  pause() {
+    privateAPI(this).pause();
+  }
+  get position() {
+    return privateAPI(this).position;
+  }
+  set position(position) {
+    privateAPI(this).position = position;
+  }
+  __experimental_getKeyframes(prop) {
+    return privateAPI(this).getKeyframesOfSimpleProp(prop);
+  }
+  async attachAudio(args) {
+    let { audioContext, destinationNode, decodedBuffer, gainNode } = await resolveAudioBuffer(args), playbackController = new AudioPlaybackController(
+      decodedBuffer,
+      audioContext,
+      gainNode
+    );
+    return privateAPI(this).replacePlaybackController(playbackController), { audioContext, destinationNode, decodedBuffer, gainNode };
+  }
+  get pointer() {
+    return privateAPI(this).pointer;
+  }
+};
+async function resolveAudioBuffer(args) {
+  function getAudioContext() {
+    if (args.audioContext)
+      return Promise.resolve(args.audioContext);
+    let ctx = new AudioContext();
+    return ctx.state === "running" || typeof window > "u" ? Promise.resolve(ctx) : new Promise((resolve) => {
+      let listener = () => {
+        ctx.resume().catch((err) => {
+          console.error(err);
+        });
+      }, eventsToHookInto = [
+        "mousedown",
+        "keydown",
+        "touchstart"
+      ], eventListenerOpts = { capture: !0, passive: !1 };
+      eventsToHookInto.forEach((eventName) => {
+        window.addEventListener(eventName, listener, eventListenerOpts);
+      }), ctx.addEventListener("statechange", () => {
+        ctx.state === "running" && (eventsToHookInto.forEach((eventName) => {
+          window.removeEventListener(eventName, listener, eventListenerOpts);
+        }), resolve(ctx));
+      });
+    });
+  }
+  async function getAudioBuffer() {
+    if (args.source instanceof AudioBuffer)
+      return args.source;
+    let decodedBufferDeferred = (0, import_defer3.defer)();
+    if (typeof args.source != "string")
+      throw new Error(
+        "Error validating arguments to sequence.attachAudio(). args.source must either be a string or an instance of AudioBuffer."
+      );
+    let fetchResponse;
+    try {
+      fetchResponse = await fetch(args.source);
+    } catch (e) {
+      throw console.error(e), new Error(
+        "Could not fetch '".concat(args.source, "'. Network error logged above.")
+      );
+    }
+    let arrayBuffer;
+    try {
+      arrayBuffer = await fetchResponse.arrayBuffer();
+    } catch (e) {
+      throw console.error(e), new Error("Could not read '".concat(args.source, "' as an arrayBuffer."));
+    }
+    (await audioContextPromise).decodeAudioData(
+      arrayBuffer,
+      decodedBufferDeferred.resolve,
+      decodedBufferDeferred.reject
+    );
+    let decodedBuffer2;
+    try {
+      decodedBuffer2 = await decodedBufferDeferred.promise;
+    } catch (e) {
+      throw console.error(e), new Error("Could not decode ".concat(args.source, " as an audio file."));
+    }
+    return decodedBuffer2;
+  }
+  let audioContextPromise = getAudioContext(), audioBufferPromise = getAudioBuffer(), [audioContext, decodedBuffer] = await Promise.all([
+    audioContextPromise,
+    audioBufferPromise
+  ]), destinationNode = args.destinationNode || audioContext.destination, gainNode = audioContext.createGain();
+  return gainNode.connect(destinationNode), {
+    audioContext,
+    decodedBuffer,
+    gainNode,
+    destinationNode
+  };
+}
+
+// src/utils/instanceTypes.ts
+var instanceTypes_exports = {};
+__export(instanceTypes_exports, {
+  isProject: () => isProject,
+  isProjectPublicAPI: () => isProjectPublicAPI,
+  isSequence: () => isSequence,
+  isSheet: () => isSheet,
+  isSheetObject: () => isSheetObject,
+  isSheetObjectPublicAPI: () => isSheetObjectPublicAPI,
+  isSheetObjectTemplate: () => isSheetObjectTemplate,
+  isSheetPublicAPI: () => isSheetPublicAPI,
+  isSheetTemplate: () => isSheetTemplate
+});
+var isProject = typeAsserter("Theatre_Project"), isSheet = typeAsserter("Theatre_Sheet"), isSheetTemplate = typeAsserter(
+  "Theatre_SheetTemplate"
+), isSheetObject = typeAsserter("Theatre_SheetObject"), isSequence = typeAsserter("Theatre_Sequence"), isSheetObjectTemplate = typeAsserter(
+  "Theatre_SheetObjectTemplate"
+), isProjectPublicAPI = typeAsserter(
+  "Theatre_Project_PublicAPI"
+), isSheetPublicAPI = typeAsserter("Theatre_Sheet_PublicAPI"), isSheetObjectPublicAPI = typeAsserter(
+  "Theatre_SheetObject_PublicAPI"
+);
+function typeAsserter(t) {
+  return (v) => typeof v == "object" && !!v && v.type === t;
+}
+
+// src/sequences/Sequence.ts
+var Sequence = class {
+  constructor(_project, _sheet, _lengthD, _subUnitsPerUnitD, playbackController) {
+    this._project = _project;
+    this._sheet = _sheet;
+    this._lengthD = _lengthD;
+    this._subUnitsPerUnitD = _subUnitsPerUnitD;
+    __publicField(this, "address");
+    __publicField(this, "publicApi");
+    __publicField(this, "_playbackControllerBox");
+    __publicField(this, "_prismOfStatePointer");
+    __publicField(this, "_positionD");
+    __publicField(this, "_positionFormatterD");
+    __publicField(this, "_playableRangeD");
+    __publicField(this, "pointer", (0, import_dataverse11.pointer)({ root: this, path: [] }));
+    __publicField(this, "$$isPointerToPrismProvider", !0);
+    __publicField(this, "closestGridPosition", (posInUnitSpace) => {
+      let gridLength = 1 / this.subUnitsPerUnit;
+      return parseFloat(
+        (Math.round(posInUnitSpace / gridLength) * gridLength).toFixed(3)
+      );
+    });
+    this.address = __spreadProps(__spreadValues({}, this._sheet.address), { sequenceName: "default" }), this.publicApi = new TheatreSequence(this), this._playbackControllerBox = new import_dataverse10.Atom(
+      playbackController != null ? playbackController : new DefaultPlaybackController()
+    ), this._prismOfStatePointer = (0, import_dataverse12.prism)(
+      () => this._playbackControllerBox.prism.getValue().statePointer
+    ), this._positionD = (0, import_dataverse12.prism)(() => {
+      let statePointer = this._prismOfStatePointer.getValue();
+      return (0, import_dataverse12.val)(statePointer.position);
+    }), this._positionFormatterD = (0, import_dataverse12.prism)(() => {
+      let subUnitsPerUnit = (0, import_dataverse12.val)(this._subUnitsPerUnitD);
+      return new TimeBasedPositionFormatter(subUnitsPerUnit);
+    });
+  }
+  get type() {
+    return "Theatre_Sequence";
+  }
+  pointerToPrism(pointer3) {
+    let { path } = (0, import_dataverse9.getPointerParts)(pointer3);
+    if (path.length === 0)
+      return (0, import_dataverse12.prism)(() => ({
+        length: (0, import_dataverse12.val)(this.pointer.length),
+        playing: (0, import_dataverse12.val)(this.pointer.playing),
+        position: (0, import_dataverse12.val)(this.pointer.position),
+        subUnitsPerUnit: (0, import_dataverse12.val)(this.pointer.subUnitsPerUnit)
+      }));
+    if (path.length > 1)
+      return (0, import_dataverse12.prism)(() => {
+      });
+    let [prop] = path;
+    return prop === "length" ? this._lengthD : prop === "subUnitsPerUnit" ? this._subUnitsPerUnitD : prop === "position" ? this._positionD : prop === "playing" ? (0, import_dataverse12.prism)(() => (0, import_dataverse12.val)(this._prismOfStatePointer.getValue().playing)) : (0, import_dataverse12.prism)(() => {
+    });
+  }
+  /**
+   * Takes a pointer to a property of a SheetObject and returns the keyframes of that property.
+   *
+   * Theoretically, this method can be called from inside a prism so it can be reactive.
+   */
+  getKeyframesOfSimpleProp(prop) {
+    let { path, root: root2 } = (0, import_dataverse9.getPointerParts)(prop);
+    if (!isSheetObject(root2))
+      throw new import_errors2.InvalidArgumentError(
+        "Argument prop must be a pointer to a SheetObject property"
+      );
+    let trackP = (0, import_dataverse12.val)(
+      this._project.pointers.historic.sheetsById[this._sheet.address.sheetId].sequence.tracksByObject[root2.address.objectKey]
+    );
+    if (!trackP)
+      return [];
+    let { trackData, trackIdByPropPath } = trackP, objectAddress = (0, import_pathToProp.encodePathToProp)(path), id = trackIdByPropPath[objectAddress];
+    if (!id)
+      return [];
+    let track = trackData[id];
+    return track ? getSortedKeyframesCached(track.keyframes) : [];
+  }
+  get positionFormatter() {
+    return this._positionFormatterD.getValue();
+  }
+  get prismOfStatePointer() {
+    return this._prismOfStatePointer;
+  }
+  get length() {
+    return this._lengthD.getValue();
+  }
+  get positionPrism() {
+    return this._positionD;
+  }
+  get position() {
+    return this._playbackControllerBox.get().getCurrentPosition();
+  }
+  get subUnitsPerUnit() {
+    return this._subUnitsPerUnitD.getValue();
+  }
+  get positionSnappedToGrid() {
+    return this.closestGridPosition(this.position);
+  }
+  set position(requestedPosition) {
+    let position = requestedPosition;
+    this.pause(), position > this.length && (position = this.length);
+    let dur = this.length;
+    this._playbackControllerBox.get().gotoPosition(position > dur ? dur : position);
+  }
+  getDurationCold() {
+    return this._lengthD.getValue();
+  }
+  get playing() {
+    return (0, import_dataverse12.val)(this._playbackControllerBox.get().statePointer.playing);
+  }
+  _makeRangeFromSequenceTemplate() {
+    return (0, import_dataverse12.prism)(() => [0, (0, import_dataverse12.val)(this._lengthD)]);
+  }
+  /**
+   * Controls the playback within a range. Repeats infinitely unless stopped.
+   *
+   * @remarks
+   *   One use case for this is to play the playback within the focus range.
+   *
+   * @param rangeD - The prism that contains the range that will be used for the playback
+   *
+   * @returns  a promise that gets rejected if the playback stopped for whatever reason
+   *
+   */
+  playDynamicRange(rangeD, ticker) {
+    return this._playbackControllerBox.get().playDynamicRange(rangeD, ticker);
+  }
+  async play(conf, ticker) {
+    let sequenceDuration = this.length, range = conf && conf.range ? conf.range : [0, sequenceDuration], iterationCount = conf && typeof conf.iterationCount == "number" ? conf.iterationCount : 1, rate = conf && typeof conf.rate < "u" ? conf.rate : 1, direction = conf && conf.direction ? conf.direction : "normal";
+    return await this._play(
+      iterationCount,
+      [range[0], range[1]],
+      rate,
+      direction,
+      ticker
+    );
+  }
+  _play(iterationCount, range, rate, direction, ticker) {
+    return this._playbackControllerBox.get().play(iterationCount, range, rate, direction, ticker);
+  }
+  pause() {
+    this._playbackControllerBox.get().pause();
+  }
+  replacePlaybackController(playbackController) {
+    this.pause();
+    let oldController = this._playbackControllerBox.get();
+    this._playbackControllerBox.set(playbackController);
+    let time = oldController.getCurrentPosition();
+    oldController.destroy(), playbackController.gotoPosition(time);
+  }
+  getMarkerPosition(markerName) {
+    let sheetState = this._project.pointers.historic.sheetsById[this._sheet.address.sheetId], markers = (0, import_dataverse12.val)(sheetState.sequence.markers);
+    if (!markers)
+      return;
+    let marker = markers.find((m) => m.label === markerName);
+    return marker == null ? void 0 : marker.position;
+  }
+  async goToAndPlay(markerName, conf, ticker) {
+    let position = this.getMarkerPosition(markerName);
+    if (position === void 0)
+      throw new Error(
+        'Marker "'.concat(markerName, '" not found in sequence "').concat(this._sheet.address.sheetId, '"')
+      );
+    return this.position = position, this.play(conf, ticker);
+  }
+  goToAndStop(markerName) {
+    let position = this.getMarkerPosition(markerName);
+    if (position === void 0)
+      throw new Error(
+        'Marker "'.concat(markerName, '" not found in sequence "').concat(this._sheet.address.sheetId, '"')
+      );
+    this.position = position;
+  }
+}, TimeBasedPositionFormatter = class {
+  constructor(_fps) {
+    this._fps = _fps;
+  }
+  formatSubUnitForGrid(posInUnitSpace) {
+    let subSecondPos = posInUnitSpace % 1, frame = 1 / this._fps;
+    return Math.round(subSecondPos / frame) + "f";
+  }
+  formatFullUnitForGrid(posInUnitSpace) {
+    let p = posInUnitSpace, s = "";
+    if (p >= hour) {
+      let hours = Math.floor(p / hour);
+      s += hours + "h", p = p % hour;
+    }
+    if (p >= minute) {
+      let minutes = Math.floor(p / minute);
+      s += minutes + "m", p = p % minute;
+    }
+    if (p >= second) {
+      let seconds = Math.floor(p / second);
+      s += seconds + "s", p = p % second;
+    }
+    let frame = 1 / this._fps;
+    if (p >= frame) {
+      let frames = Math.floor(p / frame);
+      s += frames + "f", p = p % frame;
+    }
+    return s.length === 0 ? "0s" : s;
+  }
+  formatForPlayhead(posInUnitSpace) {
+    let p = posInUnitSpace, s = "";
+    if (p >= hour) {
+      let hours = Math.floor(p / hour);
+      s += padStart_default(hours.toString(), 2, "0") + "h", p = p % hour;
+    }
+    if (p >= minute) {
+      let minutes = Math.floor(p / minute);
+      s += padStart_default(minutes.toString(), 2, "0") + "m", p = p % minute;
+    } else
+      s.length > 0 && (s += "00m");
+    if (p >= second) {
+      let seconds = Math.floor(p / second);
+      s += padStart_default(seconds.toString(), 2, "0") + "s", p = p % second;
+    } else
+      s += "00s";
+    let frameLength = 1 / this._fps;
+    if (p >= frameLength) {
+      let frames = Math.round(p / frameLength);
+      s += padStart_default(frames.toString(), 2, "0") + "f", p = p % frameLength;
+    } else
+      p / frameLength > 0.98 ? (s += padStart_default(1 .toString(), 2, "0") + "f", p = p % frameLength) : s += "00f";
+    return s.length === 0 ? "00s00f" : s;
+  }
+  formatBasic(posInUnitSpace) {
+    return posInUnitSpace.toFixed(2) + "s";
+  }
+}, second = 1, minute = second * 60, hour = minute * 60;
+
+// src/propTypes/index.ts
+var propTypes_exports = {};
+__export(propTypes_exports, {
+  boolean: () => boolean,
+  compound: () => compound,
+  file: () => file,
+  image: () => image,
+  number: () => number,
+  rgba: () => rgba,
+  string: () => string,
+  stringLiteral: () => stringLiteral
+});
+var import_userReadableTypeOfValue2 = require("@theatre/utils/userReadableTypeOfValue"), import_color = require("@theatre/utils/color");
+
+// src/types/public.ts
+var nominal = Symbol(), propTypeSymbol = Symbol("TheatrePropType_Basic");
+
+// src/propTypes/internals.ts
+var import_errors3 = require("@theatre/utils/errors"), import_userReadableTypeOfValue = __toESM(require("@theatre/utils/userReadableTypeOfValue"));
+function isLonghandPropType(t) {
+  return typeof t == "object" && !!t && t[propTypeSymbol] === "TheatrePropType";
+}
+function toLonghandProp(p) {
+  if (typeof p == "number")
+    return number(p);
+  if (typeof p == "boolean")
+    return boolean(p);
+  if (typeof p == "string")
+    return string(p);
+  if (typeof p == "object" && p) {
+    if (isLonghandPropType(p))
+      return p;
+    if (isPlainObject_default(p))
+      return compound(p);
+    throw new import_errors3.InvalidArgumentError(
+      "This value is not a valid prop type: ".concat((0, import_userReadableTypeOfValue.default)(p))
+    );
+  } else
+    throw new import_errors3.InvalidArgumentError(
+      "This value is not a valid prop type: ".concat((0, import_userReadableTypeOfValue.default)(p))
+    );
+}
+function sanitizeCompoundProps(props) {
+  let sanitizedProps = {};
+  for (let key of Object.keys(props)) {
+    let val9 = props[key];
+    isLonghandPropType(val9) ? sanitizedProps[key] = val9 : sanitizedProps[key] = toLonghandProp(val9);
+  }
+  return sanitizedProps;
+}
+
+// src/propTypes/index.ts
+var validateCommonOpts = (fnCallSignature, opts) => {
+}, compound = (props, opts = {}) => {
+  validateCommonOpts("t.compound(props, opts)", opts);
+  let sanitizedProps = sanitizeCompoundProps(props), deserializationCache = /* @__PURE__ */ new WeakMap();
+  return {
+    type: "compound",
+    props: sanitizedProps,
+    valueType: null,
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    default: mapValues_default(sanitizedProps, (p) => p.default),
+    deserializeAndSanitize: (json) => {
+      if (typeof json != "object" || !json)
+        return;
+      if (deserializationCache.has(json))
+        return deserializationCache.get(json);
+      let deserialized = {}, atLeastOnePropWasDeserialized = !1;
+      for (let [key, propConfig] of Object.entries(sanitizedProps))
+        if (Object.prototype.hasOwnProperty.call(json, key)) {
+          let deserializedSub = propConfig.deserializeAndSanitize(
+            json[key]
+          );
+          deserializedSub != null && (atLeastOnePropWasDeserialized = !0, deserialized[key] = deserializedSub);
+        }
+      if (deserializationCache.set(json, deserialized), atLeastOnePropWasDeserialized)
+        return deserialized;
+    }
+  };
+}, file = (defaultValue, opts = {}) => {
+  let interpolate = (left, right, progression) => {
+    var _a;
+    return {
+      type: "file",
+      id: ((_a = opts.interpolate) != null ? _a : leftInterpolate)(left.id, right.id, progression)
+    };
+  };
+  return {
+    type: "file",
+    default: { type: "file", id: defaultValue },
+    valueType: null,
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    interpolate,
+    deserializeAndSanitize: _ensureFile
+  };
+}, _ensureFile = (val9) => {
+  if (!val9)
+    return;
+  let valid = !0;
+  if (typeof val9.id != "string" && ![null, void 0].includes(val9.id) && (valid = !1), val9.type !== "file" && (valid = !1), !!valid)
+    return val9;
+}, image = (defaultValue, opts = {}) => {
+  let interpolate = (left, right, progression) => {
+    var _a;
+    return {
+      type: "image",
+      id: ((_a = opts.interpolate) != null ? _a : leftInterpolate)(left.id, right.id, progression)
+    };
+  };
+  return {
+    type: "image",
+    default: { type: "image", id: defaultValue },
+    valueType: null,
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    interpolate,
+    deserializeAndSanitize: _ensureImage
+  };
+}, _ensureImage = (val9) => {
+  if (!val9)
+    return;
+  let valid = !0;
+  if (typeof val9.id != "string" && ![null, void 0].includes(val9.id) && (valid = !1), val9.type !== "image" && (valid = !1), !!valid)
+    return val9;
+}, number = (defaultValue, opts = {}) => {
+  var _a;
+  return __spreadProps(__spreadValues({
+    type: "number",
+    valueType: 0,
+    default: defaultValue,
+    [propTypeSymbol]: "TheatrePropType"
+  }, opts || {}), {
+    label: opts.label,
+    nudgeFn: (_a = opts.nudgeFn) != null ? _a : defaultNumberNudgeFn,
+    nudgeMultiplier: typeof opts.nudgeMultiplier == "number" ? opts.nudgeMultiplier : void 0,
+    interpolate: _interpolateNumber,
+    deserializeAndSanitize: numberDeserializer(opts.range)
+  });
+}, numberDeserializer = (range) => range ? (json) => {
+  if (typeof json == "number" && isFinite(json))
+    return clamp_default(json, range[0], range[1]);
+} : _ensureNumber, _ensureNumber = (value) => typeof value == "number" && isFinite(value) ? value : void 0, _interpolateNumber = (left, right, progression) => left + progression * (right - left), rgba = (defaultValue = { r: 0, g: 0, b: 0, a: 1 }, opts = {}) => {
+  let sanitized = {};
+  for (let component of ["r", "g", "b", "a"])
+    sanitized[component] = Math.min(
+      Math.max(defaultValue[component], 0),
+      1
+    );
+  return {
+    type: "rgba",
+    valueType: null,
+    default: (0, import_color.decorateRgba)(sanitized),
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    interpolate: _interpolateRgba,
+    deserializeAndSanitize: _sanitizeRgba
+  };
+}, _sanitizeRgba = (val9) => {
+  if (!val9)
+    return;
+  let valid = !0;
+  for (let c of ["r", "g", "b", "a"])
+    (!Object.prototype.hasOwnProperty.call(val9, c) || typeof val9[c] != "number") && (valid = !1);
+  if (!valid)
+    return;
+  let sanitized = {};
+  for (let c of ["r", "g", "b", "a"])
+    sanitized[c] = Math.min(
+      Math.max(val9[c], 0),
+      1
+    );
+  return (0, import_color.decorateRgba)(sanitized);
+}, _interpolateRgba = (left, right, progression) => {
+  let leftLab = (0, import_color.linearSrgbToOklab)((0, import_color.srgbToLinearSrgb)(left)), rightLab = (0, import_color.linearSrgbToOklab)((0, import_color.srgbToLinearSrgb)(right)), interpolatedLab = {
+    L: (1 - progression) * leftLab.L + progression * rightLab.L,
+    a: (1 - progression) * leftLab.a + progression * rightLab.a,
+    b: (1 - progression) * leftLab.b + progression * rightLab.b,
+    alpha: (1 - progression) * leftLab.alpha + progression * rightLab.alpha
+  }, interpolatedRgba = (0, import_color.linearSrgbToSrgb)((0, import_color.oklabToLinearSrgb)(interpolatedLab));
+  return (0, import_color.decorateRgba)(interpolatedRgba);
+}, boolean = (defaultValue, opts = {}) => {
+  var _a;
+  return {
+    type: "boolean",
+    default: defaultValue,
+    valueType: null,
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    interpolate: (_a = opts.interpolate) != null ? _a : leftInterpolate,
+    deserializeAndSanitize: _ensureBoolean
+  };
+}, _ensureBoolean = (val9) => typeof val9 == "boolean" ? val9 : void 0;
+function leftInterpolate(left) {
+  return left;
+}
+var string = (defaultValue, opts = {}) => {
+  var _a;
+  return {
+    type: "string",
+    default: defaultValue,
+    valueType: null,
+    [propTypeSymbol]: "TheatrePropType",
+    label: opts.label,
+    interpolate: (_a = opts.interpolate) != null ? _a : leftInterpolate,
+    deserializeAndSanitize: _ensureString
+  };
+};
+function _ensureString(s) {
+  return typeof s == "string" ? s : void 0;
+}
+function stringLiteral(defaultValue, valuesAndLabels, opts = {}) {
+  var _a, _b;
+  return {
+    type: "stringLiteral",
+    default: defaultValue,
+    valuesAndLabels: __spreadValues({}, valuesAndLabels),
+    [propTypeSymbol]: "TheatrePropType",
+    valueType: null,
+    as: (_a = opts.as) != null ? _a : "menu",
+    label: opts.label,
+    interpolate: (_b = opts.interpolate) != null ? _b : leftInterpolate,
+    deserializeAndSanitize(json) {
+      if (typeof json == "string" && Object.prototype.hasOwnProperty.call(valuesAndLabels, json))
+        return json;
+    }
+  };
+}
+var defaultNumberNudgeFn = ({
+  config,
+  deltaX,
+  deltaFraction,
+  magnitude
+}) => {
+  var _a;
+  let { range } = config;
+  return !config.nudgeMultiplier && range && !range.includes(1 / 0) && !range.includes(-1 / 0) ? deltaFraction * (range[1] - range[0]) * magnitude : deltaX * magnitude * ((_a = config.nudgeMultiplier) != null ? _a : 1);
+};
+
+// src/sheets/TheatreSheet.ts
+var import_errors4 = require("@theatre/utils/errors"), import_slashedPaths = require("@theatre/utils/slashedPaths"), import_userReadableTypeOfValue3 = __toESM(require("@theatre/utils/userReadableTypeOfValue")), import_fast_deep_equal = __toESM(require_fast_deep_equal()), import_notify4 = require("@theatre/shared/notify");
+var TheatreSheet = class {
+  get type() {
+    return "Theatre_Sheet_PublicAPI";
+  }
+  /**
+   * @internal
+   */
+  constructor(sheet) {
+    setPrivateAPI(this, sheet);
+  }
+  object(key, config, opts) {
+    let internal = privateAPI(this), sanitizedPath = (0, import_slashedPaths.validateAndSanitiseSlashedPathOrThrow)(
+      key,
+      "sheet.object",
+      import_notify4.notify.warning
+    ), existingObject = internal.getObject(sanitizedPath), nativeObject = null, actions = opts == null ? void 0 : opts.__actions__THIS_API_IS_UNSTABLE_AND_WILL_CHANGE_IN_THE_NEXT_VERSION;
+    if (existingObject)
+      return actions && existingObject.template._temp_setActions(actions), existingObject.publicApi;
+    {
+      let sanitizedConfig = compound(config);
+      return internal.createObject(
+        sanitizedPath,
+        nativeObject,
+        sanitizedConfig,
+        actions
+      ).publicApi;
+    }
+  }
+  __experimental_getExistingObject(key) {
+    let internal = privateAPI(this), sanitizedPath = (0, import_slashedPaths.validateAndSanitiseSlashedPathOrThrow)(
+      key,
+      "sheet.object"
+    ), existingObject = internal.getObject(sanitizedPath);
+    return existingObject == null ? void 0 : existingObject.publicApi;
+  }
+  get sequence() {
+    return privateAPI(this).getSequence().publicApi;
+  }
+  get project() {
+    return privateAPI(this).project.publicApi;
+  }
+  get address() {
+    return __spreadValues({}, privateAPI(this).address);
+  }
+  detachObject(key) {
+    let internal = privateAPI(this), sanitizedPath = (0, import_slashedPaths.validateAndSanitiseSlashedPathOrThrow)(
+      key,
+      'sheet.deleteObject("'.concat(key, '")'),
+      import_notify4.notify.warning
+    );
+    if (!internal.getObject(sanitizedPath)) {
+      import_notify4.notify.warning(
+        "Couldn't delete object \"".concat(sanitizedPath, '"'),
+        'There is no object with key "'.concat(sanitizedPath, '".\n\nTo fix this, make sure you are calling `sheet.deleteObject("').concat(sanitizedPath, '")` with the correct key.')
+      ), console.warn('Object key "'.concat(sanitizedPath, '" does not exist.'));
+      return;
+    }
+    internal.deleteObject(sanitizedPath);
+  }
+};
+
+// src/sheets/Sheet.ts
+var import_dataverse13 = require("@theatre/dataverse");
+var Sheet = class {
+  constructor(template, instanceId) {
+    this.template = template;
+    this.instanceId = instanceId;
+    __publicField(this, "_objects", new import_dataverse13.Atom({}));
+    __publicField(this, "_sequence");
+    __publicField(this, "address");
+    __publicField(this, "publicApi");
+    __publicField(this, "project");
+    __publicField(this, "objectsP", this._objects.pointer);
+    __publicField(this, "type", "Theatre_Sheet");
+    this.project = template.project, this.address = __spreadProps(__spreadValues({}, template.address), {
+      sheetInstanceId: this.instanceId
+    }), this.publicApi = new TheatreSheet(this);
+  }
+  /**
+   * @remarks At some point, we have to reconcile the concept of "an object"
+   * with that of "an element."
+   */
+  createObject(objectKey, nativeObject, config, actions = {}) {
+    let object = this.template.getObjectTemplate(
+      objectKey,
+      nativeObject,
+      config,
+      actions
+    ).createInstance(this, nativeObject, config);
+    return this._objects.setByPointer((p) => p[objectKey], object), object;
+  }
+  getObject(key) {
+    return this._objects.get()[key];
+  }
+  deleteObject(objectKey) {
+    this._objects.reduce((state) => {
+      let newState = __spreadValues({}, state);
+      return delete newState[objectKey], newState;
+    });
+  }
+  getSequence() {
+    if (!this._sequence) {
+      let lengthD = (0, import_dataverse13.prism)(() => {
+        let unsanitized = (0, import_dataverse13.val)(
+          this.project.pointers.historic.sheetsById[this.address.sheetId].sequence.length
+        );
+        return sanitizeSequenceLength(unsanitized);
+      }), subUnitsPerUnitD = (0, import_dataverse13.prism)(() => {
+        let unsanitized = (0, import_dataverse13.val)(
+          this.project.pointers.historic.sheetsById[this.address.sheetId].sequence.subUnitsPerUnit
+        );
+        return sanitizeSequenceSubUnitsPerUnit(unsanitized);
+      });
+      this._sequence = new Sequence(
+        this.template.project,
+        this,
+        lengthD,
+        subUnitsPerUnitD
+      );
+    }
+    return this._sequence;
+  }
+}, sanitizeSequenceLength = (len) => typeof len == "number" && isFinite(len) && len > 0 ? len : 10, sanitizeSequenceSubUnitsPerUnit = (subs) => typeof subs == "number" && isInteger_default(subs) && subs >= 1 && subs <= 1e3 ? subs : 30;
+
+// src/sheets/SheetTemplate.ts
+var SheetTemplate = class {
+  constructor(project, sheetId) {
+    this.project = project;
+    __publicField(this, "type", "Theatre_SheetTemplate");
+    __publicField(this, "address");
+    __publicField(this, "_instances", new import_dataverse14.Atom({}));
+    __publicField(this, "instancesP", this._instances.pointer);
+    __publicField(this, "_objectTemplates", new import_dataverse14.Atom({}));
+    __publicField(this, "objectTemplatesP", this._objectTemplates.pointer);
+    this.address = __spreadProps(__spreadValues({}, project.address), { sheetId });
+  }
+  getInstance(instanceId) {
+    let inst = this._instances.get()[instanceId];
+    return inst || (inst = new Sheet(this, instanceId), this._instances.setByPointer((p) => p[instanceId], inst)), inst;
+  }
+  getObjectTemplate(objectKey, nativeObject, config, actions) {
+    let template = this._objectTemplates.get()[objectKey];
+    return template || (template = new SheetObjectTemplate(
+      this,
+      objectKey,
+      nativeObject,
+      config,
+      actions
+    ), this._objectTemplates.setByPointer((p) => p[objectKey], template)), template;
+  }
+};
+
+// src/projects/Project.ts
+var import_dataverse16 = require("@theatre/dataverse"), import_dataverse17 = require("@theatre/dataverse");
+
+// src/projects/initialiseProjectState.ts
+var import_delay = __toESM(require("@theatre/utils/delay"));
+var import_dataverse15 = require("@theatre/dataverse");
+async function initialiseProjectState(studio, project, onDiskState) {
+  await (0, import_delay.default)(0);
+  let projectId = project.address.projectId;
+  studio.ephemeralAtom.setByPointer(
+    (p) => p.coreByProject[projectId],
+    {
+      lastExportedObject: null,
+      loadingState: { type: "loading" }
+    }
+  );
+  let browserState = (0, import_dataverse15.val)(studio.atomP.historic.coreByProject[projectId]);
+  browserState ? onDiskState && browserState.revisionHistory.indexOf(onDiskState.revisionHistory[0]) == -1 ? browserStateIsNotBasedOnDiskState(onDiskState) : useBrowserState() : onDiskState ? useOnDiskState(onDiskState) : useInitialState();
+  function useInitialState() {
+    studio.transaction(({ stateEditors }) => {
+      stateEditors.coreByProject.historic.setProjectState({
+        projectId,
+        state: {
+          sheetsById: {},
+          definitionVersion: globals.currentProjectStateDefinitionVersion,
+          revisionHistory: []
+        }
+      });
+    }, !1), studio.ephemeralAtom.setByPointer(
+      (p) => p.coreByProject[projectId].loadingState,
+      {
+        type: "loaded"
+      }
+    );
+  }
+  function useOnDiskState(state) {
+    studio.transaction(({ stateEditors }) => {
+      stateEditors.coreByProject.historic.setProjectState({
+        projectId,
+        state
+      });
+    }), studio.ephemeralAtom.setByPointer(
+      (p) => p.coreByProject[projectId].loadingState,
+      {
+        type: "loaded"
+      }
+    );
+  }
+  function useBrowserState() {
+    studio.ephemeralAtom.setByPointer(
+      (p) => p.coreByProject[projectId].loadingState,
+      {
+        type: "loaded"
+      }
+    );
+  }
+  function browserStateIsNotBasedOnDiskState(onDiskState2) {
+    studio.ephemeralAtom.setByPointer(
+      (p) => p.coreByProject[projectId].loadingState,
+      {
+        type: "browserStateIsNotBasedOnDiskState",
+        onDiskState: onDiskState2
+      }
+    );
+  }
+}
+
+// src/projects/Project.ts
+var import_defer4 = require("@theatre/utils/defer");
+var import_errors5 = require("@theatre/utils/errors"), import_userReadableTypeOfValue4 = __toESM(require("@theatre/utils/userReadableTypeOfValue"));
+var Project = class {
+  constructor(id, config = {}, publicApi) {
+    this.config = config;
+    this.publicApi = publicApi;
+    __publicField(this, "pointers");
+    __publicField(this, "_pointerProxies");
+    __publicField(this, "address");
+    __publicField(this, "_studioReadyDeferred");
+    __publicField(this, "_assetStorageReadyDeferred");
+    __publicField(this, "_readyPromise");
+    __publicField(this, "_sheetTemplates", new import_dataverse17.Atom({}));
+    __publicField(this, "sheetTemplatesP", this._sheetTemplates.pointer);
+    __publicField(this, "_studio");
+    __publicField(this, "assetStorage");
+    __publicField(this, "type", "Theatre_Project");
+    var _a;
+    this.address = { projectId: id };
+    let onDiskEphemeralAtom = new import_dataverse17.Atom({
+      loadingState: {
+        type: "loaded"
+      },
+      lastExportedObject: null
+    }), onDiskStateAtom = new import_dataverse17.Atom({
+      historic: (_a = config.state) != null ? _a : {
+        sheetsById: {},
+        definitionVersion: globals.currentProjectStateDefinitionVersion,
+        revisionHistory: []
+      }
+    });
+    this._assetStorageReadyDeferred = (0, import_defer4.defer)(), this.assetStorage = {
+      getAssetUrl: (assetId) => {
+        var _a2;
+        return "".concat((_a2 = config.assets) == null ? void 0 : _a2.baseUrl, "/").concat(assetId);
+      },
+      // Until the asset storage is ready, we'll throw an error when the user tries to use it
+      createAsset: () => {
+        throw new Error("Please wait for Project.ready to use assets.");
+      }
+    }, this._pointerProxies = {
+      historic: new import_dataverse16.PointerProxy(onDiskStateAtom.pointer.historic),
+      ephemeral: new import_dataverse16.PointerProxy(onDiskEphemeralAtom.pointer)
+    }, this.pointers = {
+      historic: this._pointerProxies.historic.pointer,
+      ephemeral: this._pointerProxies.ephemeral.pointer
+    }, projectsSingleton_default.add(id, this), this._studioReadyDeferred = (0, import_defer4.defer)(), this._readyPromise = Promise.all([
+      this._studioReadyDeferred.promise,
+      this._assetStorageReadyDeferred.promise
+      // hide the array from the user, i.e. make it Promise<void> instead of Promise<[undefined, undefined]>
+    ]).then(() => {
+    }), config.state ? setTimeout(() => {
+      this._studio || (this._studioReadyDeferred.resolve(void 0), this._assetStorageReadyDeferred.resolve(void 0));
+    }, 0) : typeof window > "u" ? console.error(
+      'Argument config.state in Theatre.getProject("'.concat(id, '", config) is empty. ') + "You can safely ignore this message if you're developing a Next.js/Remix project in development mode. But if you are shipping to your end-users, then you need to set config.state, otherwise your project's state will be empty and nothing will animate. Learn more at https://www.theatrejs.com/docs/latest/manual/projects#state"
+    ) : setTimeout(() => {
+      if (!this._studio)
+        throw new Error(
+          'Argument config.state in Theatre.getProject("'.concat(id, '", config) is empty. This is fine ') + "while you are using @theatre/core along with @theatre/studio. But since @theatre/studio " + 'is not loaded, the state of project "'.concat(id, '" will be empty.\n\n') + "To fix this, you need to add @theatre/studio into the bundle and export the project's state. Learn how to do that at https://www.theatrejs.com/docs/latest/manual/projects#state\n"
+        );
+    }, 1e3);
+  }
+  attachToStudio(studio) {
+    if (this._studio) {
+      if (this._studio !== studio)
+        throw new Error(
+          "Project ".concat(this.address.projectId, " is already attached to studio ").concat(this._studio.address.studioId)
+        );
+      console.warn(
+        "Project ".concat(this.address.projectId, " is already attached to studio ").concat(this._studio.address.studioId)
+      );
+      return;
+    }
+    this._studio = studio, studio.initialized.then(async () => {
+      var _a;
+      await initialiseProjectState(studio, this, this.config.state), this._pointerProxies.historic.setPointer(
+        studio.atomP.historic.coreByProject[this.address.projectId]
+      ), this._pointerProxies.ephemeral.setPointer(
+        studio.ephemeralAtom.pointer.coreByProject[this.address.projectId]
+      ), await studio.createAssetStorage(this, (_a = this.config.assets) == null ? void 0 : _a.baseUrl).then((assetStorage) => {
+        this.assetStorage = assetStorage, this._assetStorageReadyDeferred.resolve(void 0);
+      }), this._studioReadyDeferred.resolve(void 0);
+    }).catch((err) => {
+      throw console.error(err), err;
+    });
+  }
+  get isAttachedToStudio() {
+    return !!this._studio;
+  }
+  get ready() {
+    return this._readyPromise;
+  }
+  isReady() {
+    return this._studioReadyDeferred.status === "resolved" && this._assetStorageReadyDeferred.status === "resolved";
+  }
+  getOrCreateSheet(sheetId, instanceId = "default") {
+    let template = this._sheetTemplates.get()[sheetId];
+    return template || (template = new SheetTemplate(this, sheetId), this._sheetTemplates.reduce((s) => __spreadProps(__spreadValues({}, s), { [sheetId]: template }))), template.getInstance(instanceId);
+  }
+}, shallowValidateOnDiskState = (projectId, s) => {
+  if (Array.isArray(s) || s == null || s.definitionVersion !== globals.currentProjectStateDefinitionVersion)
+    throw new import_errors5.InvalidArgumentError(
+      "Error validating conf.state in Theatre.getProject(".concat(JSON.stringify(
+        projectId
+      ), ", conf). The state seems to be formatted in a way that is unreadable to Theatre.js. Read more at https://www.theatrejs.com/docs/latest/manual/projects#state")
+    );
+}, deepValidateOnDiskState = (projectId, s) => {
+  shallowValidateOnDiskState(projectId, s);
+};
+
+// src/projects/TheatreProject.ts
+var import_sanitizers = require("@theatre/utils/sanitizers"), import_slashedPaths2 = require("@theatre/utils/slashedPaths");
+var TheatreProject = class {
+  get type() {
+    return "Theatre_Project_PublicAPI";
+  }
+  /**
+   * @internal
+   */
+  constructor(id, config = {}) {
+    setPrivateAPI(this, new Project(id, config, this));
+  }
+  get ready() {
+    return privateAPI(this).ready;
+  }
+  get isReady() {
+    return privateAPI(this).isReady();
+  }
+  get address() {
+    return __spreadValues({}, privateAPI(this).address);
+  }
+  getAssetUrl(asset) {
+    if (!this.isReady) {
+      console.error(
+        "Calling `project.getAssetUrl()` before `project.ready` is resolved, will always return `undefined`. Either use `project.ready.then(() => project.getAssetUrl())` or `await project.ready` before calling `project.getAssetUrl()`."
+      );
+      return;
+    }
+    return asset.id ? privateAPI(this).assetStorage.getAssetUrl(asset.id) : void 0;
+  }
+  sheet(sheetId, instanceId = "default") {
+    let sanitizedPath = (0, import_slashedPaths2.validateAndSanitiseSlashedPathOrThrow)(
+      sheetId,
+      "project.sheet",
+      notify.warning
+    );
+    return privateAPI(this).getOrCreateSheet(
+      sanitizedPath,
+      instanceId
+    ).publicApi;
+  }
+};
+
+// src/coreExports.ts
+var import_sanitizers2 = require("@theatre/utils/sanitizers"), import_fast_deep_equal2 = __toESM(require_fast_deep_equal()), import_dataverse18 = require("@theatre/dataverse"), import_dataverse19 = require("@theatre/dataverse");
+
+// src/utils/ids.ts
+var ids_exports = {};
+__export(ids_exports, {
+  asKeyframeId: () => asKeyframeId,
+  asSequenceTrackId: () => asSequenceTrackId
+});
+function asKeyframeId(s) {
+  return s;
+}
+function asSequenceTrackId(s) {
+  return s;
+}
+
+// src/coreExports.ts
+var __private = {
+  propTypeUtils: utils_exports,
+  ids: ids_exports,
+  instanceTypes: instanceTypes_exports,
+  keyframeUtils: keyframeUtils_exports,
+  currentProjectStateDefinitionVersion: globals.currentProjectStateDefinitionVersion
+};
+function getProject(id, config = {}) {
+  let existingProject = projectsSingleton_default.get(id);
+  return existingProject ? existingProject.publicApi : (config.state && deepValidateOnDiskState(id, config.state), new TheatreProject(id, config));
+}
+function onChange(pointer3, callback, rafDriver) {
+  let ticker = rafDriver ? privateAPI(rafDriver).ticker : getCoreTicker();
+  if ((0, import_dataverse18.isPointer)(pointer3))
+    return (0, import_dataverse19.pointerToPrism)(pointer3).onChange(ticker, callback, !0);
+  if ((0, import_dataverse19.isPrism)(pointer3))
+    return pointer3.onChange(ticker, callback, !0);
+  throw new Error(
+    "Called onChange(p) where p is neither a pointer nor a prism."
+  );
+}
+function val8(pointer3) {
+  if ((0, import_dataverse18.isPointer)(pointer3))
+    return (0, import_dataverse19.pointerToPrism)(pointer3).getValue();
+  throw new Error("Called val(p) where p is not a pointer.");
+}
+
+// src/index.ts
+var import_defer5 = require("@theatre/utils/defer");
+
+// src/env.ts
+var env = process.env;
+
+// src/CoreBundle.ts
+var CoreBundle = class {
+  constructor(_opts) {
+    this._opts = _opts;
+    __publicField(this, "_studio");
+  }
+  get type() {
+    return "Theatre_CoreBundle";
+  }
+  get version() {
+    return env.THEATRE_VERSION;
+  }
+  getBitsForStudio(studio, callback) {
+    if (this._studio)
+      throw new Error("@theatre/core is already attached to @theatre/studio");
+    this._studio = studio;
+    let bits = {
+      projectsP: projectsSingleton_default.atom.pointer.projects,
+      privateAPI,
+      coreExports: coreExports_exports,
+      getCoreRafDriver
+    };
+    callback(bits), this._opts.onAttach(studio);
+  }
+};
+
+// src/index.ts
+var studioDeferred = (0, import_defer5.defer)();
+async function getStudio() {
+  return (await studioDeferred.promise).publicApi;
+}
+function getStudioSync(errorIfNotReady = !1) {
+  if (studioDeferred.status !== "resolved") {
+    if (errorIfNotReady)
+      throw new Error("Studio is not ready yet.");
+    return;
+  }
+  return studioDeferred.currentValue.publicApi;
+}
+var initCalled = !1, initOptsDeferred = (0, import_defer5.defer)();
+async function init(opts) {
+  initCalled || (initCalled = !0, initOptsDeferred.resolve(opts));
+}
+var theatre = { getStudio, getStudioSync, init }, src_default = theatre;
+registerCoreBundle();
+function registerCoreBundle() {
+  if (typeof window > "u" && global.__THEATREJS__FORCE_CONNECT_CORE_AND_STUDIO !== !0)
+    return;
+  let globalContext = typeof window < "u" ? window : global, existingBundle = (
+    // @ts-ignore ignore
+    globalContext[globalVariableNames.coreBundle]
+  );
+  if (typeof existingBundle < "u")
+    throw typeof existingBundle == "object" && existingBundle && typeof existingBundle.version == "string" ? new Error(
+      "It seems that the module '@theatre/core' is loaded more than once. This could have two possible causes:\n1. You might have two separate versions of Theatre.js in node_modules.\n2. Or this might be a bundling misconfiguration, in case you're using a bundler like Webpack/ESBuild/Rollup.\n\nNote that it **is okay** to import '@theatre/core' multiple times. But those imports should point to the same module."
+    ) : new Error(
+      "The variable window.".concat(globalVariableNames.coreBundle, " seems to be already set by a module other than @theatre/core.")
+    );
+  let coreBundle = new CoreBundle({
+    onAttach: (s) => {
+      initOptsDeferred.promise.then((opts) => {
+        s.initialize(opts), studioDeferred.resolve(s);
+      });
+    }
+  });
+  globalContext[globalVariableNames.coreBundle] = coreBundle;
+  let possibleExistingStudioBundle = (
+    // @ts-ignore ignore
+    globalContext[globalVariableNames.studioBundle]
+  );
+  possibleExistingStudioBundle && possibleExistingStudioBundle !== null && possibleExistingStudioBundle.type === "Theatre_StudioBundle" && possibleExistingStudioBundle.registerCoreBundle(coreBundle);
+}
+/*! Bundled license information:
+
+lodash-es/lodash.js:
+  (**
+   * @license
+   * Lodash (Custom Build) <https://lodash.com/>
+   * Build: `lodash modularize exports="es" -o ./`
+   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
+   * Released under MIT license <https://lodash.com/license>
+   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+   *)
+*/
+//# sourceMappingURL=index.js.map