@unseenco/theatre-gsap 0.4.1 → 0.4.2

package/dist/index.js

@@ -22,34 +22,2385 @@ var src_exports = {};
 __export(src_exports, {
   attachGsapSequenceBridge: () => attachGsapSequenceBridge,
   configureTheatreGsap: () => configureTheatreGsap,
-  getAnimationEntry: () => getAnimationEntry,
+  getAnimationEntry: () => getAnimationEntry2,
   getAnimationEntryById: () => getAnimationEntryById,
-  getAnimationEntryForSheetObject: () => getAnimationEntryForSheetObject,
+  getAnimationEntryForSheetObject: () => getAnimationEntryForSheetObject2,
   getTheatreGsapConfig: () => getTheatreGsapConfig,
-  listAnimationEntries: () => listAnimationEntries,
+  listAnimationEntries: () => listAnimationEntries2,
   registerGsapAnimation: () => registerGsapAnimation
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/registerGsapAnimation.ts
 var import_privateAPIs = require("@unseenco/theatre-core/privateAPIs");
-var import_buildGsapSheetObjectKey = require("@unseenco/theatre-shared/gsap/buildGsapSheetObjectKey");
-var import_gsapAnimationRegistry2 = require("@unseenco/theatre-shared/gsap/gsapAnimationRegistry");
+
+// ../../theatre/shared/src/utils/errors.ts
+var TheatreError = class extends Error {
+};
+var InvalidArgumentError = class extends TheatreError {
+};
+
+// ../../theatre/shared/src/_logger/logger.ts
+function lazy(f) {
+  return function lazyLogIncluded(m, lazyArg) {
+    return f(m, lazyArg());
+  };
+}
+var LEVELS = {
+  _hmm: getLogMeta(524 /* _HMM */),
+  _todo: getLogMeta(522 /* _TODO */),
+  _error: getLogMeta(521 /* _ERROR */),
+  errorDev: getLogMeta(529 /* ERROR_DEV */),
+  errorPublic: getLogMeta(545 /* ERROR_PUBLIC */),
+  _kapow: getLogMeta(268 /* _KAPOW */),
+  _warn: getLogMeta(265 /* _WARN */),
+  warnDev: getLogMeta(273 /* WARN_DEV */),
+  warnPublic: getLogMeta(289 /* WARN_PUBLIC */),
+  _debug: getLogMeta(137 /* _DEBUG */),
+  debugDev: getLogMeta(145 /* DEBUG_DEV */),
+  _trace: getLogMeta(73 /* _TRACE */),
+  traceDev: getLogMeta(81 /* TRACE_DEV */)
+};
+function getLogMeta(level) {
+  return Object.freeze({
+    audience: hasFlag(level, 8 /* INTERNAL */) ? "internal" : hasFlag(level, 16 /* DEV */) ? "dev" : "public",
+    category: hasFlag(level, 4 /* TROUBLESHOOTING */) ? "troubleshooting" : hasFlag(level, 2 /* TODO */) ? "todo" : "general",
+    level: (
+      // I think this is equivalent... but I'm not using it until we have tests.
+      // this code won't really impact performance much anyway, since it's just computed once
+      // up front.
+      // level &
+      // (TheatreLoggerLevel.TRACE |
+      //   TheatreLoggerLevel.DEBUG |
+      //   TheatreLoggerLevel.WARN |
+      //   TheatreLoggerLevel.ERROR),
+      hasFlag(level, 512 /* ERROR */) ? 512 /* ERROR */ : hasFlag(level, 256 /* WARN */) ? 256 /* WARN */ : hasFlag(level, 128 /* DEBUG */) ? 128 /* DEBUG */ : (
+        // no other option
+        64 /* TRACE */
+      )
+    )
+  });
+}
+function hasFlag(level, flag) {
+  return (level & flag) === flag;
+}
+function shouldLog(includes, level) {
+  return ((level & 32 /* PUBLIC */) === 32 /* PUBLIC */ ? true : (level & 16 /* DEV */) === 16 /* DEV */ ? includes.dev : (level & 8 /* INTERNAL */) === 8 /* INTERNAL */ ? includes.internal : false) && includes.min <= level;
+}
+var DEFAULTS = {
+  loggingConsoleStyle: true,
+  loggerConsoleStyle: true,
+  includes: Object.freeze({
+    internal: false,
+    dev: false,
+    min: 256 /* WARN */
+  }),
+  filtered: function defaultFiltered() {
+  },
+  include: function defaultInclude() {
+    return {};
+  },
+  create: null,
+  creatExt: null,
+  named(parent, name, key) {
+    return this.create({
+      names: [...parent.names, { name, key }]
+    });
+  },
+  style: {
+    bold: void 0,
+    // /Service$/
+    italic: void 0,
+    // /Model$/
+    cssMemo: /* @__PURE__ */ new Map([
+      // handle empty names so we don't have to check for
+      // name.length > 0 during this.css('')
+      ["", ""]
+      // bring a specific override
+      // ["Marker", "color:#aea9ff;font-size:0.75em;text-transform:uppercase"]
+    ]),
+    collapseOnRE: /[a-z- ]+/g,
+    color: void 0,
+    // create collapsed name
+    // insert collapsed name into cssMemo with original's style
+    collapsed(name) {
+      if (name.length < 5)
+        return name;
+      const collapsed = name.replace(this.collapseOnRE, "");
+      if (!this.cssMemo.has(collapsed)) {
+        this.cssMemo.set(collapsed, this.css(name));
+      }
+      return collapsed;
+    },
+    css(name) {
+      const found = this.cssMemo.get(name);
+      if (found)
+        return found;
+      let css = `color:${this.color?.(name) ?? `hsl(${(name.charCodeAt(0) + name.charCodeAt(name.length - 1)) % 360}, 100%, 60%)`}`;
+      if (this.bold?.test(name)) {
+        css += ";font-weight:600";
+      }
+      if (this.italic?.test(name)) {
+        css += ";font-style:italic";
+      }
+      this.cssMemo.set(name, css);
+      return css;
+    }
+  }
+};
+function createTheatreInternalLogger(useConsole = console, _options = {}) {
+  const ref2 = { ...DEFAULTS, includes: { ...DEFAULTS.includes } };
+  const createConsole = {
+    styled: createConsoleLoggerStyled.bind(ref2, useConsole),
+    noStyle: createConsoleLoggerNoStyle.bind(ref2, useConsole)
+  };
+  const createExtBound = createExtLogger.bind(ref2);
+  function getConCreate() {
+    return ref2.loggingConsoleStyle && ref2.loggerConsoleStyle ? createConsole.styled : createConsole.noStyle;
+  }
+  ref2.create = getConCreate();
+  return {
+    configureLogger(config) {
+      if (config === "console") {
+        ref2.loggerConsoleStyle = DEFAULTS.loggerConsoleStyle;
+        ref2.create = getConCreate();
+      } else if (config.type === "console") {
+        ref2.loggerConsoleStyle = config.style ?? DEFAULTS.loggerConsoleStyle;
+        ref2.create = getConCreate();
+      } else if (config.type === "keyed") {
+        ref2.creatExt = (source2) => config.keyed(source2.names);
+        ref2.create = createExtBound;
+      } else if (config.type === "named") {
+        ref2.creatExt = configNamedToKeyed.bind(null, config.named);
+        ref2.create = createExtBound;
+      }
+    },
+    configureLogging(config) {
+      ref2.includes.dev = config.dev ?? DEFAULTS.includes.dev;
+      ref2.includes.internal = config.internal ?? DEFAULTS.includes.internal;
+      ref2.includes.min = config.min ?? DEFAULTS.includes.min;
+      ref2.include = config.include ?? DEFAULTS.include;
+      ref2.loggingConsoleStyle = config.consoleStyle ?? DEFAULTS.loggingConsoleStyle;
+      ref2.create = getConCreate();
+    },
+    getLogger() {
+      return ref2.create({ names: [] });
+    }
+  };
+}
+function configNamedToKeyed(namedFn, source2) {
+  const names = [];
+  for (let { name, key } of source2.names) {
+    names.push(key == null ? name : `${name} (${key})`);
+  }
+  return namedFn(names);
+}
+function createExtLogger(source2) {
+  const includes = { ...this.includes, ...this.include(source2) };
+  const f = this.filtered;
+  const named = this.named.bind(this, source2);
+  const ext = this.creatExt(source2);
+  const _HMM = shouldLog(includes, 524 /* _HMM */);
+  const _TODO = shouldLog(includes, 522 /* _TODO */);
+  const _ERROR = shouldLog(includes, 521 /* _ERROR */);
+  const ERROR_DEV = shouldLog(includes, 529 /* ERROR_DEV */);
+  const ERROR_PUBLIC = shouldLog(includes, 545 /* ERROR_PUBLIC */);
+  const _WARN = shouldLog(includes, 265 /* _WARN */);
+  const _KAPOW = shouldLog(includes, 268 /* _KAPOW */);
+  const WARN_DEV = shouldLog(includes, 273 /* WARN_DEV */);
+  const WARN_PUBLIC = shouldLog(includes, 289 /* WARN_PUBLIC */);
+  const _DEBUG = shouldLog(includes, 137 /* _DEBUG */);
+  const DEBUG_DEV = shouldLog(includes, 145 /* DEBUG_DEV */);
+  const _TRACE = shouldLog(includes, 73 /* _TRACE */);
+  const TRACE_DEV = shouldLog(includes, 81 /* TRACE_DEV */);
+  const _hmm = _HMM ? ext.error.bind(ext, LEVELS._hmm) : f.bind(source2, 524 /* _HMM */);
+  const _todo = _TODO ? ext.error.bind(ext, LEVELS._todo) : f.bind(source2, 522 /* _TODO */);
+  const _error = _ERROR ? ext.error.bind(ext, LEVELS._error) : f.bind(source2, 521 /* _ERROR */);
+  const errorDev = ERROR_DEV ? ext.error.bind(ext, LEVELS.errorDev) : f.bind(source2, 529 /* ERROR_DEV */);
+  const errorPublic = ERROR_PUBLIC ? ext.error.bind(ext, LEVELS.errorPublic) : f.bind(source2, 545 /* ERROR_PUBLIC */);
+  const _kapow = _KAPOW ? ext.warn.bind(ext, LEVELS._kapow) : f.bind(source2, 268 /* _KAPOW */);
+  const _warn = _WARN ? ext.warn.bind(ext, LEVELS._warn) : f.bind(source2, 265 /* _WARN */);
+  const warnDev = WARN_DEV ? ext.warn.bind(ext, LEVELS.warnDev) : f.bind(source2, 273 /* WARN_DEV */);
+  const warnPublic = WARN_PUBLIC ? ext.warn.bind(ext, LEVELS.warnPublic) : f.bind(source2, 273 /* WARN_DEV */);
+  const _debug = _DEBUG ? ext.debug.bind(ext, LEVELS._debug) : f.bind(source2, 137 /* _DEBUG */);
+  const debugDev = DEBUG_DEV ? ext.debug.bind(ext, LEVELS.debugDev) : f.bind(source2, 145 /* DEBUG_DEV */);
+  const _trace = _TRACE ? ext.trace.bind(ext, LEVELS._trace) : f.bind(source2, 73 /* _TRACE */);
+  const traceDev = TRACE_DEV ? ext.trace.bind(ext, LEVELS.traceDev) : f.bind(source2, 81 /* TRACE_DEV */);
+  const logger = {
+    _hmm,
+    _todo,
+    _error,
+    errorDev,
+    errorPublic,
+    _kapow,
+    _warn,
+    warnDev,
+    warnPublic,
+    _debug,
+    debugDev,
+    _trace,
+    traceDev,
+    lazy: {
+      _hmm: _HMM ? lazy(_hmm) : _hmm,
+      _todo: _TODO ? lazy(_todo) : _todo,
+      _error: _ERROR ? lazy(_error) : _error,
+      errorDev: ERROR_DEV ? lazy(errorDev) : errorDev,
+      errorPublic: ERROR_PUBLIC ? lazy(errorPublic) : errorPublic,
+      _kapow: _KAPOW ? lazy(_kapow) : _kapow,
+      _warn: _WARN ? lazy(_warn) : _warn,
+      warnDev: WARN_DEV ? lazy(warnDev) : warnDev,
+      warnPublic: WARN_PUBLIC ? lazy(warnPublic) : warnPublic,
+      _debug: _DEBUG ? lazy(_debug) : _debug,
+      debugDev: DEBUG_DEV ? lazy(debugDev) : debugDev,
+      _trace: _TRACE ? lazy(_trace) : _trace,
+      traceDev: TRACE_DEV ? lazy(traceDev) : traceDev
+    },
+    //
+    named,
+    utilFor: {
+      internal() {
+        return {
+          debug: logger._debug,
+          error: logger._error,
+          warn: logger._warn,
+          trace: logger._trace,
+          named(name, key) {
+            return logger.named(name, key).utilFor.internal();
+          }
+        };
+      },
+      dev() {
+        return {
+          debug: logger.debugDev,
+          error: logger.errorDev,
+          warn: logger.warnDev,
+          trace: logger.traceDev,
+          named(name, key) {
+            return logger.named(name, key).utilFor.dev();
+          }
+        };
+      },
+      public() {
+        return {
+          error: logger.errorPublic,
+          warn: logger.warnPublic,
+          debug(message, obj) {
+            logger._warn(`(public "debug" filtered out) ${message}`, obj);
+          },
+          trace(message, obj) {
+            logger._warn(`(public "trace" filtered out) ${message}`, obj);
+          },
+          named(name, key) {
+            return logger.named(name, key).utilFor.public();
+          }
+        };
+      }
+    }
+  };
+  return logger;
+}
+function createConsoleLoggerStyled(con, source2) {
+  const includes = { ...this.includes, ...this.include(source2) };
+  const styleArgs = [];
+  let prefix = "";
+  for (let i = 0; i < source2.names.length; i++) {
+    const { name, key } = source2.names[i];
+    prefix += ` %c${name}`;
+    styleArgs.push(this.style.css(name));
+    if (key != null) {
+      const keyStr = `%c#${key}`;
+      prefix += keyStr;
+      styleArgs.push(this.style.css(keyStr));
+    }
+  }
+  const f = this.filtered;
+  const named = this.named.bind(this, source2);
+  const prefixArr = [prefix, ...styleArgs];
+  return _createConsoleLogger(
+    f,
+    source2,
+    includes,
+    con,
+    prefixArr,
+    styledKapowPrefix(prefixArr),
+    named
+  );
+}
+function styledKapowPrefix(args) {
+  const start = args.slice(0);
+  for (let i = 1; i < start.length; i++)
+    start[i] += ";background-color:#e0005a;padding:2px;color:white";
+  return start;
+}
+function createConsoleLoggerNoStyle(con, source2) {
+  const includes = { ...this.includes, ...this.include(source2) };
+  let prefix = "";
+  for (let i = 0; i < source2.names.length; i++) {
+    const { name, key } = source2.names[i];
+    prefix += ` ${name}`;
+    if (key != null) {
+      prefix += `#${key}`;
+    }
+  }
+  const f = this.filtered;
+  const named = this.named.bind(this, source2);
+  const prefixArr = [prefix];
+  return _createConsoleLogger(
+    f,
+    source2,
+    includes,
+    con,
+    prefixArr,
+    prefixArr,
+    named
+  );
+}
+function _createConsoleLogger(f, source2, includes, con, prefix, kapowPrefix, named) {
+  const _HMM = shouldLog(includes, 524 /* _HMM */);
+  const _TODO = shouldLog(includes, 522 /* _TODO */);
+  const _ERROR = shouldLog(includes, 521 /* _ERROR */);
+  const ERROR_DEV = shouldLog(includes, 529 /* ERROR_DEV */);
+  const ERROR_PUBLIC = shouldLog(includes, 545 /* ERROR_PUBLIC */);
+  const _WARN = shouldLog(includes, 265 /* _WARN */);
+  const _KAPOW = shouldLog(includes, 268 /* _KAPOW */);
+  const WARN_DEV = shouldLog(includes, 273 /* WARN_DEV */);
+  const WARN_PUBLIC = shouldLog(includes, 289 /* WARN_PUBLIC */);
+  const _DEBUG = shouldLog(includes, 137 /* _DEBUG */);
+  const DEBUG_DEV = shouldLog(includes, 145 /* DEBUG_DEV */);
+  const _TRACE = shouldLog(includes, 73 /* _TRACE */);
+  const TRACE_DEV = shouldLog(includes, 81 /* TRACE_DEV */);
+  const _hmm = _HMM ? con.error.bind(con, ...prefix) : f.bind(source2, 524 /* _HMM */);
+  const _todo = _TODO ? con.error.bind(con, ...prefix) : f.bind(source2, 522 /* _TODO */);
+  const _error = _ERROR ? con.error.bind(con, ...prefix) : f.bind(source2, 521 /* _ERROR */);
+  const errorDev = ERROR_DEV ? con.error.bind(con, ...prefix) : f.bind(source2, 529 /* ERROR_DEV */);
+  const errorPublic = ERROR_PUBLIC ? con.error.bind(con, ...prefix) : f.bind(source2, 545 /* ERROR_PUBLIC */);
+  const _kapow = _KAPOW ? con.warn.bind(con, ...kapowPrefix) : f.bind(source2, 268 /* _KAPOW */);
+  const _warn = _WARN ? con.warn.bind(con, ...prefix) : f.bind(source2, 265 /* _WARN */);
+  const warnDev = WARN_DEV ? con.warn.bind(con, ...prefix) : f.bind(source2, 273 /* WARN_DEV */);
+  const warnPublic = WARN_PUBLIC ? con.warn.bind(con, ...prefix) : f.bind(source2, 273 /* WARN_DEV */);
+  const _debug = _DEBUG ? con.info.bind(con, ...prefix) : f.bind(source2, 137 /* _DEBUG */);
+  const debugDev = DEBUG_DEV ? con.info.bind(con, ...prefix) : f.bind(source2, 145 /* DEBUG_DEV */);
+  const _trace = _TRACE ? con.debug.bind(con, ...prefix) : f.bind(source2, 73 /* _TRACE */);
+  const traceDev = TRACE_DEV ? con.debug.bind(con, ...prefix) : f.bind(source2, 81 /* TRACE_DEV */);
+  const logger = {
+    _hmm,
+    _todo,
+    _error,
+    errorDev,
+    errorPublic,
+    _kapow,
+    _warn,
+    warnDev,
+    warnPublic,
+    _debug,
+    debugDev,
+    _trace,
+    traceDev,
+    lazy: {
+      _hmm: _HMM ? lazy(_hmm) : _hmm,
+      _todo: _TODO ? lazy(_todo) : _todo,
+      _error: _ERROR ? lazy(_error) : _error,
+      errorDev: ERROR_DEV ? lazy(errorDev) : errorDev,
+      errorPublic: ERROR_PUBLIC ? lazy(errorPublic) : errorPublic,
+      _kapow: _KAPOW ? lazy(_kapow) : _kapow,
+      _warn: _WARN ? lazy(_warn) : _warn,
+      warnDev: WARN_DEV ? lazy(warnDev) : warnDev,
+      warnPublic: WARN_PUBLIC ? lazy(warnPublic) : warnPublic,
+      _debug: _DEBUG ? lazy(_debug) : _debug,
+      debugDev: DEBUG_DEV ? lazy(debugDev) : debugDev,
+      _trace: _TRACE ? lazy(_trace) : _trace,
+      traceDev: TRACE_DEV ? lazy(traceDev) : traceDev
+    },
+    //
+    named,
+    utilFor: {
+      internal() {
+        return {
+          debug: logger._debug,
+          error: logger._error,
+          warn: logger._warn,
+          trace: logger._trace,
+          named(name, key) {
+            return logger.named(name, key).utilFor.internal();
+          }
+        };
+      },
+      dev() {
+        return {
+          debug: logger.debugDev,
+          error: logger.errorDev,
+          warn: logger.warnDev,
+          trace: logger.traceDev,
+          named(name, key) {
+            return logger.named(name, key).utilFor.dev();
+          }
+        };
+      },
+      public() {
+        return {
+          error: logger.errorPublic,
+          warn: logger.warnPublic,
+          debug(message, obj) {
+            logger._warn(`(public "debug" filtered out) ${message}`, obj);
+          },
+          trace(message, obj) {
+            logger._warn(`(public "trace" filtered out) ${message}`, obj);
+          },
+          named(name, key) {
+            return logger.named(name, key).utilFor.public();
+          }
+        };
+      }
+    }
+  };
+  return logger;
+}
+
+// ../../theatre/shared/src/logger.ts
+var internal = createTheatreInternalLogger(console, {
+  _debug: function() {
+  },
+  _error: function() {
+  }
+});
+internal.configureLogging({
+  dev: true,
+  min: 64 /* TRACE */
+});
+var logger_default = internal.getLogger().named("Theatre.js (default logger)").utilFor.dev();
+
+// ../../theatre/shared/src/globalVariableNames.ts
+var notifications = "__TheatreJS_Notifications";
+
+// ../../theatre/shared/src/notify.ts
+var createHandler = (type) => (...args) => {
+  switch (type) {
+    case "success": {
+      logger_default.debug(args.slice(0, 2).join("\n"));
+      break;
+    }
+    case "info": {
+      logger_default.debug(args.slice(0, 2).join("\n"));
+      break;
+    }
+    case "warning": {
+      logger_default.warn(args.slice(0, 2).join("\n"));
+      break;
+    }
+    case "error": {
+    }
+  }
+  return typeof window !== "undefined" ? (
+    // @ts-ignore
+    window[notifications]?.notify[type](...args)
+  ) : void 0;
+};
+var notify = {
+  warning: createHandler("warning"),
+  success: createHandler("success"),
+  info: createHandler("info"),
+  error: createHandler("error")
+};
+if (typeof window !== "undefined") {
+  window.addEventListener("error", (e) => {
+    notify.error(
+      `An error occurred`,
+      `<pre>${e.message}</pre>
+
+See **console** for details.`
+    );
+  });
+  window.addEventListener("unhandledrejection", (e) => {
+    notify.error(
+      `An error occurred`,
+      `<pre>${e.reason}</pre>
+
+See **console** for details.`
+    );
+  });
+}
+
+// ../../theatre/shared/src/utils/slashedPaths.ts
+var normalizeSlashedPath = (p) => p.replace(/^[\s\/]*/, "").replace(/[\s\/]*$/, "").replace(/\s*\/\s*/g, " / ");
+var getValidationErrorsOfSlashedPath = (p) => {
+  if (typeof p !== "string")
+    return `it is not a string. (it is a ${typeof p})`;
+  const components = p.split(/\//);
+  if (components.length === 0)
+    return `it is empty.`;
+  for (let i = 0; i < components.length; i++) {
+    const component = components[i].trim();
+    if (component.length === 0)
+      return `the component #${i + 1} is empty.`;
+    if (component.length > 64)
+      return `the component '${component}' must have 64 characters or less.`;
+  }
+};
+function validateAndSanitiseSlashedPathOrThrow(unsanitisedPath, fnName) {
+  const sanitisedPath = normalizeSlashedPath(unsanitisedPath);
+  if (process.env.NODE_ENV !== "development") {
+    return sanitisedPath;
+  }
+  const validation = getValidationErrorsOfSlashedPath(sanitisedPath);
+  if (validation) {
+    throw new InvalidArgumentError(
+      `The path in ${fnName}(${typeof unsanitisedPath === "string" ? `"${unsanitisedPath}"` : ""}) is invalid because ${validation}`
+    );
+  }
+  if (unsanitisedPath !== sanitisedPath) {
+    notify.warning(
+      "Invalid path provided to object",
+      `The path in \`${fnName}("${unsanitisedPath}")\` was sanitized to \`"${sanitisedPath}"\`.
+
+Please replace the path with the sanitized one, otherwise it will likely break in the future.`,
+      [
+        {
+          url: "https://www.theatrejs.com/docs/latest/manual/objects#creating-sheet-objects",
+          title: "Sheet Objects"
+        },
+        {
+          url: "https://www.theatrejs.com/docs/latest/api/core#sheet.object",
+          title: "API"
+        }
+      ]
+    );
+  }
+  return sanitisedPath;
+}
+
+// ../../theatre/shared/src/gsap/buildGsapSheetObjectKey.ts
+function buildGsapSheetObjectKey(namespace, label) {
+  return validateAndSanitiseSlashedPathOrThrow(
+    `${namespace} / ${label}`,
+    "buildGsapSheetObjectKey"
+  );
+}
+
+// ../../theatre/shared/src/gsap/introspectGsapTimelineChildren.ts
+function isGsapTimeline(animation) {
+  const root2 = animation;
+  const children = root2.getChildren?.(false, true, false);
+  return Array.isArray(children) && children.length > 0;
+}
+function childLabel(child, index) {
+  const tween = child;
+  const id = tween.vars?.id;
+  if (typeof id === "string" && id.length > 0)
+    return id;
+  return `Tween ${index + 1}`;
+}
+function readChildLocalTiming(child) {
+  const tween = child;
+  const localStart = typeof tween.startTime === "function" ? tween.startTime() : 0;
+  let localDuration = typeof tween.duration === "function" ? tween.duration() : 0;
+  if (localDuration <= 0 && typeof tween.endTime === "function") {
+    localDuration = Math.max(tween.endTime() - localStart, 0.01);
+  }
+  return {
+    localStart: Math.max(localStart, 0),
+    localDuration: Math.max(localDuration, 0.01)
+  };
+}
+function introspectGsapTimelineChildren(animation) {
+  if (!isGsapTimeline(animation))
+    return [];
+  const root2 = animation;
+  const raw = root2.getChildren(false, true, false);
+  return raw.map((child, index) => {
+    const { localStart, localDuration } = readChildLocalTiming(child);
+    return {
+      childId: `child_${index}`,
+      label: childLabel(child, index),
+      localStart,
+      localDuration
+    };
+  });
+}
+function linkGsapTimelineChildAnimations(animation) {
+  const map = /* @__PURE__ */ new Map();
+  if (!isGsapTimeline(animation))
+    return map;
+  const root2 = animation;
+  const raw = root2.getChildren(false, true, false);
+  raw.forEach((child, index) => {
+    map.set(`child_${index}`, child);
+  });
+  return map;
+}
+
+// ../../theatre/shared/src/gsap/gsapSheetObjectKey.ts
+var GSAP_NAMESPACE_STORE_KEY = "__unseenco_theatre_gsap_configuredNamespace__";
+function setConfiguredGsapSheetObjectNamespace(namespace) {
+  const g = globalThis;
+  g[GSAP_NAMESPACE_STORE_KEY] = namespace.trim();
+}
+
+// ../../theatre/shared/src/sequence/trackData.ts
+function gsapClipEndTime(clip) {
+  return clip.start + clip.duration;
+}
+function gsapClipSyncProgress(sequencePosition, clip) {
+  if (clip.duration <= 0)
+    return 0;
+  if (sequencePosition < clip.start)
+    return 0;
+  const clipEnd = gsapClipEndTime(clip);
+  if (sequencePosition >= clipEnd - 1e-5)
+    return 1;
+  const raw = (sequencePosition - clip.start) / clip.duration;
+  if (raw <= 0)
+    return 0;
+  if (raw >= 1)
+    return 1;
+  return raw;
+}
+
+// ../../theatre/shared/src/gsap/applyTimelineChildTiming.ts
+function applyTimelineChildTimingToGsap(rootAnimation, timelineChildren, childById, onRebuild) {
+  if (!timelineChildren.length)
+    return true;
+  let ok = applyTimelineChildTimingToGsapInner(
+    rootAnimation,
+    timelineChildren,
+    childById
+  );
+  if (!ok && onRebuild) {
+    const rebuilt = onRebuild();
+    if (rebuilt) {
+      ok = applyTimelineChildTimingToGsapInner(
+        rebuilt,
+        timelineChildren,
+        childById
+      );
+    }
+  }
+  return ok;
+}
+function applyTimelineChildTimingToGsapInner(rootAnimation, timelineChildren, childById) {
+  if (!childById || timelineChildren.length === 0)
+    return true;
+  let ok = true;
+  for (const childState of timelineChildren) {
+    const tween = childById.get(childState.childId);
+    if (!tween)
+      continue;
+    try {
+      const t = tween;
+      if (typeof t.startTime === "function") {
+        t.startTime(childState.localStart);
+      }
+      if (typeof t.duration === "function") {
+        t.duration(childState.localDuration);
+      }
+    } catch {
+      ok = false;
+    }
+  }
+  return ok;
+}
+
+// ../../theatre/shared/src/gsap/syncGsapClipProgress.ts
+function getGsapAnimationTargetKey(animation, fallbackAnimationId) {
+  const tween = animation;
+  const targets = tween.targets?.();
+  if (targets && targets.length > 0) {
+    return targets[0];
+  }
+  return fallbackAnimationId;
+}
+function syncRegisteredGsapAnimationsForClips(sequencePosition, clips) {
+  const enriched = [];
+  for (const clip of clips) {
+    const entry = getAnimationEntryBySheetAddressKey(
+      clip.sheetObjectAddressKey,
+      clip.gsapAnimationId
+    );
+    if (!entry?.animation)
+      continue;
+    enriched.push({
+      ...clip,
+      entry,
+      targetKey: getGsapAnimationTargetKey(
+        entry.animation,
+        clip.gsapAnimationId
+      )
+    });
+  }
+  const byTarget = /* @__PURE__ */ new Map();
+  for (const item of enriched) {
+    const list = byTarget.get(item.targetKey) ?? [];
+    list.push(item);
+    byTarget.set(item.targetKey, list);
+  }
+  for (const group of byTarget.values()) {
+    const sorted = [...group].sort((a, b) => a.start - b.start);
+    for (const clip of sorted) {
+      const progress = gsapClipSyncProgress(sequencePosition, clip);
+      const entry = clip.entry;
+      const animation = entry.animation;
+      if (entry.kind === "timeline" && clip.timelineChildren && clip.timelineChildren.length > 0) {
+        applyTimelineChildTimingToGsap(
+          entry.animation,
+          clip.timelineChildren,
+          entry.timelineChildById,
+          entry.onRebuildTimeline
+        );
+        const span = clip.timelineSpan ?? readGsapTweenTimelineDuration(entry.animation);
+        const t = progress * Math.max(span, 0.01);
+        if (typeof animation.time === "function") {
+          animation.time(t, true);
+        } else {
+          animation.progress?.(progress, true);
+        }
+      } else {
+        animation.progress?.(progress, true);
+      }
+    }
+  }
+}
+function readGsapTweenTimelineDuration(animation) {
+  const tween = animation;
+  const total = tween.totalDuration?.();
+  if (typeof total === "number" && total > 0)
+    return total;
+  const d = tween.duration();
+  return d > 0 ? d : 1;
+}
+
+// ../../theatre/shared/src/gsap/gsapClipBaseline.ts
+function cloneTimelineChildren(children) {
+  return children.map((c) => ({ ...c }));
+}
+function buildGsapClipBaselineTiming(p) {
+  const duration = Math.max(p.duration, 0.01);
+  const baseline = { duration };
+  if (p.timelineChildren && p.timelineChildren.length > 0) {
+    baseline.timelineSpan = p.timelineSpan ?? duration;
+    baseline.timelineChildren = cloneTimelineChildren(p.timelineChildren);
+  }
+  return baseline;
+}
+
+// ../../theatre/shared/src/gsap/gsapObjectBinding.ts
+var STORE_KEY = "__unseenco_theatre_gsap_objectBindings__";
+function addressKey(sheetObject) {
+  const a = sheetObject.address;
+  return `${a.projectId}|${a.sheetId}|${a.sheetInstanceId}|${a.objectKey}`;
+}
+function getStore() {
+  const g = globalThis;
+  if (!g[STORE_KEY]) {
+    g[STORE_KEY] = /* @__PURE__ */ new Map();
+  }
+  return g[STORE_KEY];
+}
+function registerGsapObjectBinding(sheetObject, binding) {
+  getStore().set(addressKey(sheetObject), binding);
+}
+
+// ../../node_modules/lodash-es/isArray.js
+var isArray = Array.isArray;
+var isArray_default = isArray;
+
+// ../../node_modules/lodash-es/_freeGlobal.js
+var freeGlobal = typeof window == "object" && window && window.Object === Object && window;
+var freeGlobal_default = freeGlobal;
+
+// ../../node_modules/lodash-es/_root.js
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal_default || freeSelf || Function("return this")();
+var root_default = root;
+
+// ../../node_modules/lodash-es/_Symbol.js
+var Symbol2 = root_default.Symbol;
+var Symbol_default = Symbol2;
+
+// ../../node_modules/lodash-es/_getRawTag.js
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+var nativeObjectToString = objectProto.toString;
+var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+  try {
+    value[symToStringTag] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag] = tag;
+    } else {
+      delete value[symToStringTag];
+    }
+  }
+  return result;
+}
+var getRawTag_default = getRawTag;
+
+// ../../node_modules/lodash-es/_objectToString.js
+var objectProto2 = Object.prototype;
+var nativeObjectToString2 = objectProto2.toString;
+function objectToString(value) {
+  return nativeObjectToString2.call(value);
+}
+var objectToString_default = objectToString;
+
+// ../../node_modules/lodash-es/_baseGetTag.js
+var nullTag = "[object Null]";
+var undefinedTag = "[object Undefined]";
+var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
+}
+var baseGetTag_default = baseGetTag;
+
+// ../../node_modules/lodash-es/isObjectLike.js
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_default = isObjectLike;
+
+// ../../node_modules/lodash-es/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)\]/;
+var reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray_default(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol_default(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var isKey_default = isKey;
+
+// ../../node_modules/lodash-es/isObject.js
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_default = isObject;
+
+// ../../node_modules/lodash-es/isFunction.js
+var asyncTag = "[object AsyncFunction]";
+var funcTag = "[object Function]";
+var genTag = "[object GeneratorFunction]";
+var proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject_default(value)) {
+    return false;
+  }
+  var tag = baseGetTag_default(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_default = isFunction;
+
+// ../../node_modules/lodash-es/_coreJsData.js
+var coreJsData = root_default["__core-js_shared__"];
+var coreJsData_default = coreJsData;
+
+// ../../node_modules/lodash-es/_isMasked.js
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData_default && coreJsData_default.keys && coreJsData_default.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var isMasked_default = isMasked;
+
+// ../../node_modules/lodash-es/_toSource.js
+var funcProto = Function.prototype;
+var funcToString = funcProto.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var toSource_default = toSource;
+
+// ../../node_modules/lodash-es/_baseIsNative.js
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto2 = Function.prototype;
+var objectProto3 = Object.prototype;
+var funcToString2 = funcProto2.toString;
+var hasOwnProperty2 = objectProto3.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString2.call(hasOwnProperty2).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject_default(value) || isMasked_default(value)) {
+    return false;
+  }
+  var pattern = isFunction_default(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource_default(value));
+}
+var baseIsNative_default = baseIsNative;
+
+// ../../node_modules/lodash-es/_getValue.js
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var getValue_default = getValue;
+
+// ../../node_modules/lodash-es/_getNative.js
+function getNative(object, key) {
+  var value = getValue_default(object, key);
+  return baseIsNative_default(value) ? value : void 0;
+}
+var getNative_default = getNative;
+
+// ../../node_modules/lodash-es/_nativeCreate.js
+var nativeCreate = getNative_default(Object, "create");
+var nativeCreate_default = nativeCreate;
+
+// ../../node_modules/lodash-es/_hashClear.js
+function hashClear() {
+  this.__data__ = nativeCreate_default ? nativeCreate_default(null) : {};
+  this.size = 0;
+}
+var hashClear_default = hashClear;
+
+// ../../node_modules/lodash-es/_hashDelete.js
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var hashDelete_default = hashDelete;
+
+// ../../node_modules/lodash-es/_hashGet.js
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+var objectProto4 = Object.prototype;
+var hasOwnProperty3 = objectProto4.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate_default) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? void 0 : result;
+  }
+  return hasOwnProperty3.call(data, key) ? data[key] : void 0;
+}
+var hashGet_default = hashGet;
+
+// ../../node_modules/lodash-es/_hashHas.js
+var objectProto5 = Object.prototype;
+var hasOwnProperty4 = objectProto5.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate_default ? data[key] !== void 0 : hasOwnProperty4.call(data, key);
+}
+var hashHas_default = hashHas;
+
+// ../../node_modules/lodash-es/_hashSet.js
+var HASH_UNDEFINED2 = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate_default && value === void 0 ? HASH_UNDEFINED2 : value;
+  return this;
+}
+var hashSet_default = hashSet;
+
+// ../../node_modules/lodash-es/_Hash.js
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear_default;
+Hash.prototype["delete"] = hashDelete_default;
+Hash.prototype.get = hashGet_default;
+Hash.prototype.has = hashHas_default;
+Hash.prototype.set = hashSet_default;
+var Hash_default = Hash;
+
+// ../../node_modules/lodash-es/_listCacheClear.js
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var listCacheClear_default = listCacheClear;
+
+// ../../node_modules/lodash-es/eq.js
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_default = eq;
+
+// ../../node_modules/lodash-es/_assocIndexOf.js
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq_default(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var assocIndexOf_default = assocIndexOf;
+
+// ../../node_modules/lodash-es/_listCacheDelete.js
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var listCacheDelete_default = listCacheDelete;
+
+// ../../node_modules/lodash-es/_listCacheGet.js
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var listCacheGet_default = listCacheGet;
+
+// ../../node_modules/lodash-es/_listCacheHas.js
+function listCacheHas(key) {
+  return assocIndexOf_default(this.__data__, key) > -1;
+}
+var listCacheHas_default = listCacheHas;
+
+// ../../node_modules/lodash-es/_listCacheSet.js
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf_default(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var listCacheSet_default = listCacheSet;
+
+// ../../node_modules/lodash-es/_ListCache.js
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear_default;
+ListCache.prototype["delete"] = listCacheDelete_default;
+ListCache.prototype.get = listCacheGet_default;
+ListCache.prototype.has = listCacheHas_default;
+ListCache.prototype.set = listCacheSet_default;
+var ListCache_default = ListCache;
+
+// ../../node_modules/lodash-es/_Map.js
+var Map2 = getNative_default(root_default, "Map");
+var Map_default = Map2;
+
+// ../../node_modules/lodash-es/_mapCacheClear.js
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash_default(),
+    "map": new (Map_default || ListCache_default)(),
+    "string": new Hash_default()
+  };
+}
+var mapCacheClear_default = mapCacheClear;
+
+// ../../node_modules/lodash-es/_isKeyable.js
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var isKeyable_default = isKeyable;
+
+// ../../node_modules/lodash-es/_getMapData.js
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable_default(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var getMapData_default = getMapData;
+
+// ../../node_modules/lodash-es/_mapCacheDelete.js
+function mapCacheDelete(key) {
+  var result = getMapData_default(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var mapCacheDelete_default = mapCacheDelete;
+
+// ../../node_modules/lodash-es/_mapCacheGet.js
+function mapCacheGet(key) {
+  return getMapData_default(this, key).get(key);
+}
+var mapCacheGet_default = mapCacheGet;
+
+// ../../node_modules/lodash-es/_mapCacheHas.js
+function mapCacheHas(key) {
+  return getMapData_default(this, key).has(key);
+}
+var mapCacheHas_default = mapCacheHas;
+
+// ../../node_modules/lodash-es/_mapCacheSet.js
+function mapCacheSet(key, value) {
+  var data = getMapData_default(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var mapCacheSet_default = mapCacheSet;
+
+// ../../node_modules/lodash-es/_MapCache.js
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear_default;
+MapCache.prototype["delete"] = mapCacheDelete_default;
+MapCache.prototype.get = mapCacheGet_default;
+MapCache.prototype.has = mapCacheHas_default;
+MapCache.prototype.set = mapCacheSet_default;
+var MapCache_default = MapCache;
+
+// ../../node_modules/lodash-es/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], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache_default)();
+  return 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) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var memoizeCapped_default = memoizeCapped;
+
+// ../../node_modules/lodash-es/_stringToPath.js
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped_default(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var stringToPath_default = stringToPath;
+
+// ../../node_modules/lodash-es/_arrayMap.js
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++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;
+var symbolProto = Symbol_default ? Symbol_default.prototype : void 0;
+var 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) {
+  if (isArray_default(value)) {
+    return value;
+  }
+  return isKey_default(value, object) ? [value] : stringToPath_default(toString_default(value));
+}
+var castPath_default = castPath;
+
+// ../../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/_baseGet.js
+function baseGet(object, path) {
+  path = castPath_default(path, object);
+  var index = 0, length = path.length;
+  while (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/_overArg.js
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var overArg_default = overArg;
+
+// ../../node_modules/lodash-es/_getPrototype.js
+var getPrototype = overArg_default(Object.getPrototypeOf, Object);
+var getPrototype_default = getPrototype;
+
+// ../../node_modules/lodash-es/isPlainObject.js
+var objectTag = "[object Object]";
+var funcProto3 = Function.prototype;
+var objectProto6 = Object.prototype;
+var funcToString3 = funcProto3.toString;
+var hasOwnProperty5 = objectProto6.hasOwnProperty;
+var objectCtorString = funcToString3.call(Object);
+function isPlainObject(value) {
+  if (!isObjectLike_default(value) || baseGetTag_default(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype_default(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty5.call(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString3.call(Ctor) == objectCtorString;
+}
+var isPlainObject_default = isPlainObject;
+
+// ../../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;
+
+// ../dataverse/src/pointer.ts
+var pointerMetaWeakMap = /* @__PURE__ */ new WeakMap();
+var cachedSubPathPointersWeakMap = /* @__PURE__ */ new WeakMap();
+var pointerMetaSymbol = Symbol("pointerMeta");
+var proxyHandler = {
+  get(pointerKey, prop) {
+    if (prop === pointerMetaSymbol)
+      return pointerMetaWeakMap.get(pointerKey);
+    let subPathPointers = cachedSubPathPointersWeakMap.get(pointerKey);
+    if (!subPathPointers) {
+      subPathPointers = /* @__PURE__ */ new Map();
+      cachedSubPathPointersWeakMap.set(pointerKey, subPathPointers);
+    }
+    const existing = subPathPointers.get(prop);
+    if (existing !== void 0)
+      return existing;
+    const meta = pointerMetaWeakMap.get(pointerKey);
+    const subPointer = pointer({ root: meta.root, path: [...meta.path, prop] });
+    subPathPointers.set(prop, subPointer);
+    return subPointer;
+  }
+};
+var getPointerMeta = (p) => {
+  const meta = p[pointerMetaSymbol];
+  return meta;
+};
+var getPointerParts = (p) => {
+  const { root: root2, path } = getPointerMeta(p);
+  return { root: root2, path };
+};
+function pointer(args) {
+  const meta = {
+    root: args.root,
+    path: args.path ?? []
+  };
+  const pointerKey = {};
+  pointerMetaWeakMap.set(pointerKey, meta);
+  return new Proxy(pointerKey, proxyHandler);
+}
+var pointer_default = pointer;
+var isPointer = (p) => {
+  return p && !!getPointerMeta(p);
+};
+
+// ../dataverse/src/utils/updateDeep.ts
+function updateDeep(state2, path, reducer) {
+  if (path.length === 0)
+    return reducer(state2);
+  return hoop(state2, path, reducer);
+}
+var hoop = (s, path, reducer) => {
+  if (path.length === 0) {
+    return reducer(s);
+  }
+  if (Array.isArray(s)) {
+    let [index, ...restOfPath] = path;
+    index = parseInt(String(index), 10);
+    if (isNaN(index))
+      index = 0;
+    const oldVal = s[index];
+    const newVal = hoop(oldVal, restOfPath, reducer);
+    if (oldVal === newVal)
+      return s;
+    const newS = [...s];
+    newS.splice(index, 1, newVal);
+    return newS;
+  } else if (typeof s === "object" && s !== null) {
+    const [key, ...restOfPath] = path;
+    const oldVal = s[key];
+    const newVal = hoop(oldVal, restOfPath, reducer);
+    if (oldVal === newVal)
+      return s;
+    const newS = { ...s, [key]: newVal };
+    return newS;
+  } else {
+    const [key, ...restOfPath] = path;
+    return { [key]: hoop(void 0, restOfPath, reducer) };
+  }
+};
+
+// ../dataverse/src/utils/Stack.ts
+var Stack = class {
+  constructor() {
+    this._head = void 0;
+  }
+  peek() {
+    return this._head && this._head.data;
+  }
+  pop() {
+    const head = this._head;
+    if (!head) {
+      return void 0;
+    }
+    this._head = head.next;
+    return head.data;
+  }
+  push(data) {
+    const node = { next: this._head, data };
+    this._head = node;
+  }
+};
+
+// ../dataverse/src/prism/Interface.ts
+function isPrism(d) {
+  return !!(d && d.isPrism && d.isPrism === true);
+}
+
+// ../dataverse/src/prism/discoveryMechanism.ts
+function createMechanism() {
+  const noop = () => {
+  };
+  const stack = new Stack();
+  const noopCollector = noop;
+  const pushCollector2 = (collector) => {
+    stack.push(collector);
+  };
+  const popCollector2 = (collector) => {
+    const existing = stack.peek();
+    if (existing !== collector) {
+      throw new Error(`Popped collector is not on top of the stack`);
+    }
+    stack.pop();
+  };
+  const startIgnoringDependencies2 = () => {
+    stack.push(noopCollector);
+  };
+  const stopIgnoringDependencies2 = () => {
+    if (stack.peek() !== noopCollector) {
+      if (process.env.NODE_ENV === "development") {
+        console.warn("This should never happen");
+      }
+    } else {
+      stack.pop();
+    }
+  };
+  const reportResolutionStart2 = (d) => {
+    const possibleCollector = stack.peek();
+    if (possibleCollector) {
+      possibleCollector(d);
+    }
+    stack.push(noopCollector);
+  };
+  const reportResolutionEnd2 = (_d) => {
+    stack.pop();
+  };
+  return {
+    type: "Dataverse_discoveryMechanism",
+    startIgnoringDependencies: startIgnoringDependencies2,
+    stopIgnoringDependencies: stopIgnoringDependencies2,
+    reportResolutionStart: reportResolutionStart2,
+    reportResolutionEnd: reportResolutionEnd2,
+    pushCollector: pushCollector2,
+    popCollector: popCollector2
+  };
+}
+function getSharedMechanism() {
+  const varName = "__dataverse_discoveryMechanism_sharedStack";
+  const root2 = typeof window !== "undefined" ? window : typeof window !== "undefined" ? window : {};
+  if (root2) {
+    const existingMechanism = (
+      // @ts-ignore ignore
+      root2[varName]
+    );
+    if (existingMechanism && typeof existingMechanism === "object" && existingMechanism.type === "Dataverse_discoveryMechanism") {
+      return existingMechanism;
+    } else {
+      const mechanism = createMechanism();
+      root2[varName] = mechanism;
+      return mechanism;
+    }
+  } else {
+    return createMechanism();
+  }
+}
+var {
+  startIgnoringDependencies,
+  stopIgnoringDependencies,
+  reportResolutionEnd,
+  reportResolutionStart,
+  pushCollector,
+  popCollector
+} = getSharedMechanism();
+
+// ../dataverse/src/prism/prism.ts
+var voidFn = () => {
+};
+var HotHandle = class {
+  constructor(_fn, _prismInstance) {
+    this._fn = _fn;
+    this._prismInstance = _prismInstance;
+    this._didMarkDependentsAsStale = false;
+    this._isFresh = false;
+    this._cacheOfDendencyValues = /* @__PURE__ */ new Map();
+    /**
+     * @internal
+     */
+    this._dependents = /* @__PURE__ */ new Set();
+    /**
+     * @internal
+     */
+    this._dependencies = /* @__PURE__ */ new Set();
+    this._possiblyStaleDeps = /* @__PURE__ */ new Set();
+    this._scope = new HotScope(
+      this
+    );
+    /**
+     * @internal
+     */
+    this._lastValue = void 0;
+    /**
+     * If true, the prism is stale even though its dependencies aren't
+     * marked as such. This is used by `prism.source()` and `prism.state()`
+     * to mark the prism as stale.
+     */
+    this._forciblySetToStale = false;
+    this._reactToDependencyGoingStale = (which) => {
+      this._possiblyStaleDeps.add(which);
+      this._markAsStale();
+    };
+    for (const d of this._dependencies) {
+      d._addDependent(this._reactToDependencyGoingStale);
+    }
+    startIgnoringDependencies();
+    this.getValue();
+    stopIgnoringDependencies();
+  }
+  get hasDependents() {
+    return this._dependents.size > 0;
+  }
+  removeDependent(d) {
+    this._dependents.delete(d);
+  }
+  addDependent(d) {
+    this._dependents.add(d);
+  }
+  destroy() {
+    for (const d of this._dependencies) {
+      d._removeDependent(this._reactToDependencyGoingStale);
+    }
+    cleanupScopeStack(this._scope);
+  }
+  getValue() {
+    if (!this._isFresh) {
+      const newValue = this._recalculate();
+      this._lastValue = newValue;
+      this._isFresh = true;
+      this._didMarkDependentsAsStale = false;
+      this._forciblySetToStale = false;
+    }
+    return this._lastValue;
+  }
+  _recalculate() {
+    let value;
+    if (!this._forciblySetToStale) {
+      if (this._possiblyStaleDeps.size > 0) {
+        let anActuallyStaleDepWasFound = false;
+        startIgnoringDependencies();
+        for (const dep of this._possiblyStaleDeps) {
+          if (this._cacheOfDendencyValues.get(dep) !== dep.getValue()) {
+            anActuallyStaleDepWasFound = true;
+            break;
+          }
+        }
+        stopIgnoringDependencies();
+        this._possiblyStaleDeps.clear();
+        if (!anActuallyStaleDepWasFound) {
+          return this._lastValue;
+        }
+      }
+    }
+    const newDeps = /* @__PURE__ */ new Set();
+    this._cacheOfDendencyValues.clear();
+    const collector = (observedDep) => {
+      newDeps.add(observedDep);
+      this._addDependency(observedDep);
+    };
+    pushCollector(collector);
+    hookScopeStack.push(this._scope);
+    try {
+      value = this._fn();
+    } catch (error) {
+      console.error(error);
+    } finally {
+      const topOfTheStack = hookScopeStack.pop();
+      if (topOfTheStack !== this._scope) {
+        console.warn(
+          // @todo guide the user to report the bug in an issue
+          `The Prism hook stack has slipped. This is a bug.`
+        );
+      }
+    }
+    popCollector(collector);
+    for (const dep of this._dependencies) {
+      if (!newDeps.has(dep)) {
+        this._removeDependency(dep);
+      }
+    }
+    this._dependencies = newDeps;
+    startIgnoringDependencies();
+    for (const dep of newDeps) {
+      this._cacheOfDendencyValues.set(dep, dep.getValue());
+    }
+    stopIgnoringDependencies();
+    return value;
+  }
+  forceStale() {
+    this._forciblySetToStale = true;
+    this._markAsStale();
+  }
+  _markAsStale() {
+    if (this._didMarkDependentsAsStale)
+      return;
+    this._didMarkDependentsAsStale = true;
+    this._isFresh = false;
+    for (const dependent of this._dependents) {
+      dependent(this._prismInstance);
+    }
+  }
+  /**
+   * @internal
+   */
+  _addDependency(d) {
+    if (this._dependencies.has(d))
+      return;
+    this._dependencies.add(d);
+    d._addDependent(this._reactToDependencyGoingStale);
+  }
+  /**
+   * @internal
+   */
+  _removeDependency(d) {
+    if (!this._dependencies.has(d))
+      return;
+    this._dependencies.delete(d);
+    d._removeDependent(this._reactToDependencyGoingStale);
+  }
+};
+var emptyObject = {};
+var PrismInstance = class {
+  constructor(_fn) {
+    this._fn = _fn;
+    /**
+     * Whether the object is a prism.
+     */
+    this.isPrism = true;
+    this._state = {
+      hot: false,
+      handle: void 0
+    };
+  }
+  /**
+   * Whether the prism is hot.
+   */
+  get isHot() {
+    return this._state.hot;
+  }
+  onChange(ticker, listener, immediate = false) {
+    const dependent = () => {
+      ticker.onThisOrNextTick(refresh);
+    };
+    let lastValue = (
+      // use an empty object as the initial value so that the listener is called on the first tick.
+      // if we were to use, say, undefined, and this.getValue() also returned undefined, the listener
+      // would never be called.
+      emptyObject
+    );
+    const refresh = () => {
+      const newValue = this.getValue();
+      if (newValue === lastValue)
+        return;
+      lastValue = newValue;
+      listener(newValue);
+    };
+    this._addDependent(dependent);
+    if (immediate) {
+      lastValue = this.getValue();
+      listener(lastValue);
+    }
+    const unsubscribe = () => {
+      this._removeDependent(dependent);
+      ticker.offThisOrNextTick(refresh);
+      ticker.offNextTick(refresh);
+    };
+    return unsubscribe;
+  }
+  /**
+   * Calls `callback` every time the prism's state goes from `fresh-\>stale.` Returns an `unsubscribe()` function.
+   */
+  onStale(callback) {
+    const untap = () => {
+      this._removeDependent(fn);
+    };
+    const fn = () => callback();
+    this._addDependent(fn);
+    return untap;
+  }
+  /**
+   * Keep the prism hot, even if there are no tappers (subscribers).
+   */
+  keepHot() {
+    return this.onStale(() => {
+    });
+  }
+  /**
+   * Add a prism as a dependent of this prism.
+   *
+   * @param d - The prism to be made a dependent of this prism.
+   *
+   * @see _removeDependent
+   */
+  _addDependent(d) {
+    if (!this._state.hot) {
+      this._goHot();
+    }
+    this._state.handle.addDependent(d);
+  }
+  _goHot() {
+    const hotHandle = new HotHandle(this._fn, this);
+    this._state = {
+      hot: true,
+      handle: hotHandle
+    };
+  }
+  /**
+   * Remove a prism as a dependent of this prism.
+   *
+   * @param d - The prism to be removed from as a dependent of this prism.
+   *
+   * @see _addDependent
+   */
+  _removeDependent(d) {
+    const state2 = this._state;
+    if (!state2.hot) {
+      return;
+    }
+    const handle = state2.handle;
+    handle.removeDependent(d);
+    if (!handle.hasDependents) {
+      this._state = { hot: false, handle: void 0 };
+      handle.destroy();
+    }
+  }
+  /**
+   * Gets the current value of the prism. If the value is stale, it causes the prism to freshen.
+   */
+  getValue() {
+    reportResolutionStart(this);
+    const state2 = this._state;
+    let val2;
+    if (state2.hot) {
+      val2 = state2.handle.getValue();
+    } else {
+      val2 = calculateColdPrism(this._fn);
+    }
+    reportResolutionEnd(this);
+    return val2;
+  }
+};
+var HotScope = class _HotScope {
+  constructor(_hotHandle) {
+    this._hotHandle = _hotHandle;
+    this._refs = /* @__PURE__ */ new Map();
+    this.isPrismScope = true;
+    // NOTE probably not a great idea to eager-allocate all of these objects/maps for every scope,
+    // especially because most wouldn't get used in the majority of cases. However, back when these
+    // were stored on weakmaps, they were uncomfortable to inspect in the debugger.
+    this.subs = {};
+    this.effects = /* @__PURE__ */ new Map();
+    this.memos = /* @__PURE__ */ new Map();
+  }
+  ref(key, initialValue) {
+    let ref2 = this._refs.get(key);
+    if (ref2 !== void 0) {
+      return ref2;
+    } else {
+      const ref3 = {
+        current: initialValue
+      };
+      this._refs.set(key, ref3);
+      return ref3;
+    }
+  }
+  effect(key, cb, deps) {
+    let effect2 = this.effects.get(key);
+    if (effect2 === void 0) {
+      effect2 = {
+        cleanup: voidFn,
+        deps: void 0
+      };
+      this.effects.set(key, effect2);
+    }
+    if (depsHaveChanged(effect2.deps, deps)) {
+      effect2.cleanup();
+      startIgnoringDependencies();
+      effect2.cleanup = safelyRun(cb, voidFn).value;
+      stopIgnoringDependencies();
+      effect2.deps = deps;
+    }
+  }
+  memo(key, fn, deps) {
+    let memo2 = this.memos.get(key);
+    if (memo2 === void 0) {
+      memo2 = {
+        cachedValue: null,
+        // undefined will always indicate "deps have changed", so we set its initial value as such
+        deps: void 0
+      };
+      this.memos.set(key, memo2);
+    }
+    if (depsHaveChanged(memo2.deps, deps)) {
+      startIgnoringDependencies();
+      memo2.cachedValue = safelyRun(fn, void 0).value;
+      stopIgnoringDependencies();
+      memo2.deps = deps;
+    }
+    return memo2.cachedValue;
+  }
+  state(key, initialValue) {
+    const { value, setValue } = this.memo(
+      "state/" + key,
+      () => {
+        const value2 = { current: initialValue };
+        const setValue2 = (newValue) => {
+          value2.current = newValue;
+          this._hotHandle.forceStale();
+        };
+        return { value: value2, setValue: setValue2 };
+      },
+      []
+    );
+    return [value.current, setValue];
+  }
+  sub(key) {
+    if (!this.subs[key]) {
+      this.subs[key] = new _HotScope(this._hotHandle);
+    }
+    return this.subs[key];
+  }
+  cleanupEffects() {
+    for (const effect2 of this.effects.values()) {
+      safelyRun(effect2.cleanup, void 0);
+    }
+    this.effects.clear();
+  }
+  source(subscribe, getValue2) {
+    const sourceKey = "$$source/blah";
+    this.effect(
+      sourceKey,
+      () => {
+        const unsub = subscribe(() => {
+          this._hotHandle.forceStale();
+        });
+        return unsub;
+      },
+      [subscribe]
+    );
+    return getValue2();
+  }
+};
+function cleanupScopeStack(scope2) {
+  for (const sub2 of Object.values(scope2.subs)) {
+    cleanupScopeStack(sub2);
+  }
+  scope2.cleanupEffects();
+}
+function safelyRun(fn, returnValueInCaseOfError) {
+  try {
+    return { value: fn(), ok: true };
+  } catch (error) {
+    setTimeout(function PrismReportThrow() {
+      throw error;
+    });
+    return { value: returnValueInCaseOfError, ok: false };
+  }
+}
+var hookScopeStack = new Stack();
+function ref(key, initialValue) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.ref() is called outside of a prism() call.`);
+  }
+  return scope2.ref(key, initialValue);
+}
+function effect(key, cb, deps) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.effect() is called outside of a prism() call.`);
+  }
+  return scope2.effect(key, cb, deps);
+}
+function depsHaveChanged(oldDeps, newDeps) {
+  if (oldDeps === void 0 || newDeps === void 0) {
+    return true;
+  }
+  const len = oldDeps.length;
+  if (len !== newDeps.length)
+    return true;
+  for (let i = 0; i < len; i++) {
+    if (oldDeps[i] !== newDeps[i])
+      return true;
+  }
+  return false;
+}
+function memo(key, fn, deps) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.memo() is called outside of a prism() call.`);
+  }
+  return scope2.memo(key, fn, deps);
+}
+function state(key, initialValue) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.state() is called outside of a prism() call.`);
+  }
+  return scope2.state(key, initialValue);
+}
+function ensurePrism() {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`The parent function is called outside of a prism() call.`);
+  }
+}
+function scope(key, fn) {
+  const parentScope = hookScopeStack.peek();
+  if (!parentScope) {
+    throw new Error(`prism.scope() is called outside of a prism() call.`);
+  }
+  const subScope = parentScope.sub(key);
+  hookScopeStack.push(subScope);
+  const ret = safelyRun(fn, void 0).value;
+  hookScopeStack.pop();
+  return ret;
+}
+function sub(key, fn, deps) {
+  return memo(key, () => prism(fn), deps).getValue();
+}
+function inPrism() {
+  return !!hookScopeStack.peek();
+}
+function source(subscribe, getValue2) {
+  const scope2 = hookScopeStack.peek();
+  if (!scope2) {
+    throw new Error(`prism.source() is called outside of a prism() call.`);
+  }
+  return scope2.source(subscribe, getValue2);
+}
+var prism = (fn) => {
+  return new PrismInstance(fn);
+};
+var ColdScope = class _ColdScope {
+  effect(key, cb, deps) {
+    console.warn(`prism.effect() does not run in cold prisms`);
+  }
+  memo(key, fn, deps) {
+    return fn();
+  }
+  state(key, initialValue) {
+    return [initialValue, () => {
+    }];
+  }
+  ref(key, initialValue) {
+    return { current: initialValue };
+  }
+  sub(key) {
+    return new _ColdScope();
+  }
+  source(subscribe, getValue2) {
+    return getValue2();
+  }
+};
+function calculateColdPrism(fn) {
+  const scope2 = new ColdScope();
+  hookScopeStack.push(scope2);
+  let value;
+  try {
+    value = fn();
+  } catch (error) {
+    console.error(error);
+  } finally {
+    const topOfTheStack = hookScopeStack.pop();
+    if (topOfTheStack !== scope2) {
+      console.warn(
+        // @todo guide the user to report the bug in an issue
+        `The Prism hook stack has slipped. This is a bug.`
+      );
+    }
+  }
+  return value;
+}
+prism.ref = ref;
+prism.effect = effect;
+prism.memo = memo;
+prism.ensurePrism = ensurePrism;
+prism.state = state;
+prism.scope = scope;
+prism.sub = sub;
+prism.inPrism = inPrism;
+prism.source = source;
+var prism_default = prism;
+
+// ../dataverse/src/Atom.ts
+var getTypeOfValue = (v) => {
+  if (Array.isArray(v))
+    return 1 /* Array */;
+  if (isPlainObject_default(v))
+    return 0 /* Dict */;
+  return 2 /* Other */;
+};
+var getKeyOfValue = (v, key, vType = getTypeOfValue(v)) => {
+  if (vType === 0 /* Dict */ && typeof key === "string") {
+    return v[key];
+  } else if (vType === 1 /* Array */ && isValidArrayIndex(key)) {
+    return v[key];
+  } else {
+    return void 0;
+  }
+};
+var isValidArrayIndex = (key) => {
+  const inNumber = typeof key === "number" ? key : parseInt(key, 10);
+  return !isNaN(inNumber) && inNumber >= 0 && inNumber < Infinity && (inNumber | 0) === inNumber;
+};
+var Scope = class _Scope {
+  constructor(_parent, _path) {
+    this._parent = _parent;
+    this._path = _path;
+    this.children = /* @__PURE__ */ new Map();
+    this.identityChangeListeners = /* @__PURE__ */ new Set();
+  }
+  addIdentityChangeListener(cb) {
+    this.identityChangeListeners.add(cb);
+  }
+  removeIdentityChangeListener(cb) {
+    this.identityChangeListeners.delete(cb);
+    this._checkForGC();
+  }
+  removeChild(key) {
+    this.children.delete(key);
+    this._checkForGC();
+  }
+  getChild(key) {
+    return this.children.get(key);
+  }
+  getOrCreateChild(key) {
+    let child = this.children.get(key);
+    if (!child) {
+      child = child = new _Scope(this, this._path.concat([key]));
+      this.children.set(key, child);
+    }
+    return child;
+  }
+  _checkForGC() {
+    if (this.identityChangeListeners.size > 0)
+      return;
+    if (this.children.size > 0)
+      return;
+    if (this._parent) {
+      this._parent.removeChild(last_default(this._path));
+    }
+  }
+};
+var Atom = class {
+  constructor(initialState) {
+    /**
+     * @internal
+     */
+    this.$$isPointerToPrismProvider = true;
+    /**
+     * Convenience property that gives you a pointer to the root of the atom.
+     *
+     * @remarks
+     * Equivalent to `pointer({ root: thisAtom, path: [] })`.
+     */
+    this.pointer = pointer_default({ root: this, path: [] });
+    this.prism = this.pointerToPrism(
+      this.pointer
+    );
+    this._onPointerValueChange = (pointer2, cb) => {
+      const { path } = getPointerParts(pointer2);
+      const scope2 = this._getOrCreateScopeForPath(path);
+      scope2.identityChangeListeners.add(cb);
+      const unsubscribe = () => {
+        scope2.identityChangeListeners.delete(cb);
+      };
+      return unsubscribe;
+    };
+    this._currentState = initialState;
+    this._rootScope = new Scope(void 0, []);
+  }
+  /**
+   * Sets the state of the atom.
+   *
+   * @param newState - The new state of the atom.
+   */
+  set(newState) {
+    const oldState = this._currentState;
+    this._currentState = newState;
+    this._checkUpdates(this._rootScope, oldState, newState);
+  }
+  get() {
+    return this._currentState;
+  }
+  /**
+   * Returns the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.getByPointer(atom.pointer.a.b) // 1
+   * atom.getByPointer((p) => p.a.b) // 1
+   * ```
+   */
+  getByPointer(pointerOrFn) {
+    const pointer2 = isPointer(pointerOrFn) ? pointerOrFn : pointerOrFn(this.pointer);
+    const path = getPointerParts(pointer2).path;
+    return this._getIn(path);
+  }
+  /**
+   * Gets the state of the atom at `path`.
+   */
+  _getIn(path) {
+    return path.length === 0 ? this.get() : get_default(this.get(), path);
+  }
+  reduce(fn) {
+    this.set(fn(this.get()));
+  }
+  /**
+   * Reduces the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.reduceByPointer(atom.pointer.a.b, (b) => b + 1) // atom.get().a.b === 2
+   * atom.reduceByPointer((p) => p.a.b, (b) => b + 1) // atom.get().a.b === 2
+   * ```
+   */
+  reduceByPointer(pointerOrFn, reducer) {
+    const pointer2 = isPointer(pointerOrFn) ? pointerOrFn : pointerOrFn(this.pointer);
+    const path = getPointerParts(pointer2).path;
+    const newState = updateDeep(this.get(), path, reducer);
+    this.set(newState);
+  }
+  /**
+   * Sets the value at the given pointer
+   *
+   * @param pointerOrFn - A pointer to the desired path. Could also be a function returning a pointer
+   *
+   * Example
+   * ```ts
+   * const atom = atom({ a: { b: 1 } })
+   * atom.setByPointer(atom.pointer.a.b, 2) // atom.get().a.b === 2
+   * atom.setByPointer((p) => p.a.b, 2) // atom.get().a.b === 2
+   * ```
+   */
+  setByPointer(pointerOrFn, val2) {
+    this.reduceByPointer(pointerOrFn, () => val2);
+  }
+  _checkUpdates(scope2, oldState, newState) {
+    if (oldState === newState)
+      return;
+    for (const cb of scope2.identityChangeListeners) {
+      cb(newState);
+    }
+    if (scope2.children.size === 0)
+      return;
+    const oldValueType = getTypeOfValue(oldState);
+    const newValueType = getTypeOfValue(newState);
+    if (oldValueType === 2 /* Other */ && oldValueType === newValueType)
+      return;
+    for (const [childKey, childScope] of scope2.children) {
+      const oldChildVal = getKeyOfValue(oldState, childKey, oldValueType);
+      const newChildVal = getKeyOfValue(newState, childKey, newValueType);
+      this._checkUpdates(childScope, oldChildVal, newChildVal);
+    }
+  }
+  _getOrCreateScopeForPath(path) {
+    let curScope = this._rootScope;
+    for (const pathEl of path) {
+      curScope = curScope.getOrCreateChild(pathEl);
+    }
+    return curScope;
+  }
+  /**
+   * Returns a new prism of the value at the provided path.
+   *
+   * @param pointer - The path to create the prism at.
+   *
+   * ```ts
+   * const pr = atom({ a: { b: 1 } }).pointerToPrism(atom.pointer.a.b)
+   * pr.getValue() // 1
+   * ```
+   */
+  pointerToPrism(pointer2) {
+    const { path } = getPointerParts(pointer2);
+    const subscribe = (listener) => this._onPointerValueChange(pointer2, listener);
+    const getValue2 = () => this._getIn(path);
+    return prism_default(() => {
+      return prism_default.source(subscribe, getValue2);
+    });
+  }
+};
+
+// ../dataverse/src/pointerToPrism.ts
+var identifyPrismWeakMap = /* @__PURE__ */ new WeakMap();
+function isPointerToPrismProvider(val2) {
+  return typeof val2 === "object" && val2 !== null && val2["$$isPointerToPrismProvider"] === true;
+}
+var pointerToPrism = (pointer2) => {
+  const meta = getPointerMeta(pointer2);
+  let prismInstance = identifyPrismWeakMap.get(meta);
+  if (!prismInstance) {
+    const root2 = meta.root;
+    if (!isPointerToPrismProvider(root2)) {
+      throw new Error(
+        `Cannot run pointerToPrism() on a pointer whose root is not an PointerToPrismProvider`
+      );
+    }
+    prismInstance = root2.pointerToPrism(pointer2);
+    identifyPrismWeakMap.set(meta, prismInstance);
+  }
+  return prismInstance;
+};
+
+// ../dataverse/src/val.ts
+var val = (input) => {
+  if (isPointer(input)) {
+    return pointerToPrism(input).getValue();
+  } else if (isPrism(input)) {
+    return input.getValue();
+  } else {
+    return input;
+  }
+};
+
+// ../../theatre/shared/src/gsap/gsapStudioRegistryRevision.ts
+var revisionAtom = new Atom(0);
+function bumpGsapStudioRegistryRevision() {
+  revisionAtom.set(revisionAtom.get() + 1);
+}
+var gsapStudioRegistryRevisionPointer = revisionAtom.pointer;
+
+// ../../theatre/shared/src/gsap/gsapAnimationRegistry.ts
+var DEFAULT_SHEET_INSTANCE_ID = "default";
+var REGISTRY_KEY = "__unseenco_theatre_gsap_animationRegistry__";
+function sheetObjectAddressKeyFromParts(address) {
+  const sheetInstanceId = address.sheetInstanceId ?? DEFAULT_SHEET_INSTANCE_ID;
+  return `${address.projectId}|${address.sheetId}|${sheetInstanceId}|${address.objectKey}`;
+}
+function sheetObjectAddressKey(sheetObject) {
+  return sheetObjectAddressKeyFromParts(sheetObject.address);
+}
+function getStore2() {
+  const g = globalThis;
+  if (!g[REGISTRY_KEY]) {
+    g[REGISTRY_KEY] = {
+      bySheetAddress: /* @__PURE__ */ new Map()
+    };
+  }
+  return g[REGISTRY_KEY];
+}
+function getSheetEntryMap(sheetKey) {
+  const store = getStore2();
+  let map = store.bySheetAddress.get(sheetKey);
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    store.bySheetAddress.set(sheetKey, map);
+  }
+  return map;
+}
+function registerAnimationInRegistry(entry) {
+  const kind = entry.animation && isGsapTimeline(entry.animation) ? "timeline" : "tween";
+  const timelineChildById = kind === "timeline" && entry.animation ? linkGsapTimelineChildAnimations(entry.animation) : void 0;
+  const defaultDuration = entry.defaultDuration ?? readGsapTweenTimelineDuration(entry.animation);
+  const timelineChildren = kind === "timeline" && entry.animation ? introspectGsapTimelineChildren(entry.animation) : [];
+  const originalTiming = entry.originalTiming ?? (entry.animation ? buildGsapClipBaselineTiming({
+    duration: defaultDuration,
+    ...timelineChildren.length > 0 ? {
+      timelineSpan: readGsapTweenTimelineDuration(entry.animation),
+      timelineChildren
+    } : {}
+  }) : void 0);
+  const normalized = {
+    ...entry,
+    kind,
+    timelineChildById,
+    originalTiming
+  };
+  if (entry.sheetObject) {
+    const sheetKey = sheetObjectAddressKey(entry.sheetObject);
+    getSheetEntryMap(sheetKey).set(entry.id, normalized);
+    registerGsapObjectBinding(entry.sheetObject, {
+      gsapAnimationId: entry.id,
+      defaultDuration
+    });
+  }
+  bumpGsapStudioRegistryRevision();
+}
+function getAnimationEntryForAddress(address, animationId) {
+  const animId = animationId ?? address.objectKey;
+  const sheetKey = sheetObjectAddressKeyFromParts(address);
+  return getStore2().bySheetAddress.get(sheetKey)?.get(animId);
+}
+function getAnimationEntry(sheetObject, animationId) {
+  return getAnimationEntryForAddress(
+    sheetObject.address,
+    animationId ?? sheetObject.address.objectKey
+  );
+}
+function getAnimationEntryForSheetObject(sheetObject) {
+  return getAnimationEntry(sheetObject);
+}
+function getAnimationEntryBySheetAddressKey(sheetObjectAddressKey2, animationId) {
+  return getStore2().bySheetAddress.get(sheetObjectAddressKey2)?.get(animationId);
+}
+function listAnimationEntries() {
+  const entries = [];
+  for (const byAnim of getStore2().bySheetAddress.values()) {
+    entries.push(...byAnim.values());
+  }
+  return entries;
+}
 
 // src/config.ts
-var import_gsapSheetObjectKey = require("@unseenco/theatre-shared/gsap/gsapSheetObjectKey");
 var activeConfig = {
   namespace: "GSAP",
   outlineNamespace: { defaultCollapsed: false }
 };
-(0, import_gsapSheetObjectKey.setConfiguredGsapSheetObjectNamespace)(activeConfig.namespace);
+setConfiguredGsapSheetObjectNamespace(activeConfig.namespace);
 function configureTheatreGsap(config) {
   const prev = activeConfig;
   activeConfig = {
     namespace: config.namespace ?? prev.namespace ?? "GSAP",
     outlineNamespace: config.outlineNamespace ?? prev.outlineNamespace
   };
-  (0, import_gsapSheetObjectKey.setConfiguredGsapSheetObjectNamespace)(activeConfig.namespace ?? "GSAP");
+  setConfiguredGsapSheetObjectNamespace(activeConfig.namespace ?? "GSAP");
   return {
     reset() {
       activeConfig = prev;
@@ -61,10 +2412,8 @@ function getTheatreGsapConfig() {
 }
 
 // src/animationRegistry.ts
-var import_gsapAnimationRegistry = require("@unseenco/theatre-shared/gsap/gsapAnimationRegistry");
-var import_syncGsapClipProgress = require("@unseenco/theatre-shared/gsap/syncGsapClipProgress");
-function registerAnimationInRegistry(entry) {
-  (0, import_gsapAnimationRegistry.registerAnimationInRegistry)({
+function registerAnimationInRegistry2(entry) {
+  registerAnimationInRegistry({
     ...entry,
     animation: entry.animation,
     defaultDuration: entry.defaultDuration ?? defaultClipDuration(entry.animation),
@@ -72,7 +2421,7 @@ function registerAnimationInRegistry(entry) {
   });
 }
 function defaultClipDuration(animation) {
-  return (0, import_syncGsapClipProgress.readGsapTweenTimelineDuration)(animation);
+  return readGsapTweenTimelineDuration(animation);
 }
 function toPackageEntry(entry) {
   if (!entry || !entry.animation)
@@ -86,19 +2435,19 @@ function toPackageEntry(entry) {
     onRebuildTimeline: entry.onRebuildTimeline
   };
 }
-function getAnimationEntry(sheetObject, animationId) {
-  return toPackageEntry((0, import_gsapAnimationRegistry.getAnimationEntry)(sheetObject, animationId));
+function getAnimationEntry2(sheetObject, animationId) {
+  return toPackageEntry(getAnimationEntry(sheetObject, animationId));
 }
 function getAnimationEntryById(id) {
   return toPackageEntry(
-    (0, import_gsapAnimationRegistry.listAnimationEntries)().find((entry) => entry.id === id)
+    listAnimationEntries().find((entry) => entry.id === id)
   );
 }
-function getAnimationEntryForSheetObject(sheetObject) {
-  return toPackageEntry((0, import_gsapAnimationRegistry.getAnimationEntryForSheetObject)(sheetObject));
+function getAnimationEntryForSheetObject2(sheetObject) {
+  return toPackageEntry(getAnimationEntryForSheetObject(sheetObject));
 }
-function listAnimationEntries() {
-  return (0, import_gsapAnimationRegistry.listAnimationEntries)().filter((e) => !!e.animation).map((entry) => ({
+function listAnimationEntries2() {
+  return listAnimationEntries().filter((e) => !!e.animation).map((entry) => ({
     id: entry.id,
     label: entry.label,
     animation: entry.animation,
@@ -106,24 +2455,28 @@ function listAnimationEntries() {
   }));
 }
 
+// ../../theatre/shared/src/utils/outlineNamespaces.ts
+function formatOutlineNamespacePathKey(pathSegments) {
+  return pathSegments.join(" / ");
+}
+
 // src/registerGsapAnimation.ts
-var import_outlineNamespaces = require("@unseenco/theatre-shared/utils/outlineNamespaces");
 function registerGsapAnimation(animation, sheet, options) {
   const config = getTheatreGsapConfig();
   const namespace = options.namespace ?? config.namespace ?? "GSAP";
-  const objectKey = (0, import_buildGsapSheetObjectKey.buildGsapSheetObjectKey)(namespace, options.label);
+  const objectKey = buildGsapSheetObjectKey(namespace, options.label);
   const id = options.id ?? objectKey;
   animation.pause();
   const sheetObjectPublic = sheet.object(objectKey, {}, { reconfigure: false });
   const sheetObjectInternal = (0, import_privateAPIs.privateAPI)(sheetObjectPublic);
-  const existing = (0, import_gsapAnimationRegistry2.getAnimationEntry)(sheetObjectInternal, id);
+  const existing = getAnimationEntry(sheetObjectInternal, id);
   if (config.outlineNamespace && !existing) {
     (0, import_privateAPIs.privateAPI)(sheet).template.setOutlineNamespaceConfig(
-      (0, import_outlineNamespaces.formatOutlineNamespacePathKey)([namespace]),
+      formatOutlineNamespacePathKey([namespace]),
       config.outlineNamespace
     );
   }
-  registerAnimationInRegistry({
+  registerAnimationInRegistry2({
     id,
     label: options.label,
     animation,
@@ -136,15 +2489,43 @@ function registerGsapAnimation(animation, sheet, options) {
 
 // src/attachGsapSequenceBridge.ts
 var import_privateAPIs2 = require("@unseenco/theatre-core/privateAPIs");
-var import_gsapAnimationRegistry3 = require("@unseenco/theatre-shared/gsap/gsapAnimationRegistry");
-var import_subscribeGsapClipSyncAtPlayhead = require("@unseenco/theatre-shared/gsap/subscribeGsapClipSyncAtPlayhead");
+
+// ../../theatre/shared/src/gsap/syncGsapClipsAtSequencePosition.ts
+function syncGsapClipsAtSequencePosition(position, clips) {
+  syncRegisteredGsapAnimationsForClips(
+    position,
+    clips
+  );
+}
+
+// ../../theatre/shared/src/gsap/subscribeGsapClipSyncAtPlayhead.ts
+function subscribeGsapClipSyncAtPlayhead(source2) {
+  const positionPointer = source2.pointer.position;
+  const positionPrism = pointerToPrism(positionPointer);
+  const clipsPrism = prism_default(() => source2.getGsapClipTimings());
+  const syncNow = () => {
+    const clips = clipsPrism.getValue();
+    if (clips.length === 0)
+      return;
+    syncGsapClipsAtSequencePosition(val(positionPointer), clips);
+  };
+  const untapPosition = positionPrism.onStale(syncNow);
+  const untapClips = clipsPrism.onStale(syncNow);
+  syncNow();
+  return () => {
+    untapPosition();
+    untapClips();
+  };
+}
+
+// src/attachGsapSequenceBridge.ts
 function attachGsapSequenceBridge(sheet) {
   const sequence = sheet.sequence;
   const sheetAddress = (0, import_privateAPIs2.privateAPI)(sheet).address;
-  return (0, import_subscribeGsapClipSyncAtPlayhead.subscribeGsapClipSyncAtPlayhead)({
+  return subscribeGsapClipSyncAtPlayhead({
     pointer: sequence.pointer,
     getGsapClipTimings: () => sequence.__experimental_getGsapClips().map(({ objectKey, clip }) => ({
-      sheetObjectAddressKey: (0, import_gsapAnimationRegistry3.sheetObjectAddressKeyFromParts)({
+      sheetObjectAddressKey: sheetObjectAddressKeyFromParts({
         projectId: sheetAddress.projectId,
         sheetId: sheetAddress.sheetId,
         sheetInstanceId: sheetAddress.sheetInstanceId,