remotion 4.0.472 → 4.0.474

package/dist/esm/index.mjs

@@ -1291,7 +1291,7 @@ var addSequenceStackTraces = (component) => {
 };
 
 // src/version.ts
-var VERSION = "4.0.472";
+var VERSION = "4.0.474";
 
 // src/multiple-versions-warning.ts
 var checkMultipleRemotionVersions = () => {
@@ -1355,7 +1355,8 @@ __export(exports_timeline_position_state, {
   useAbsoluteTimelinePosition: () => useAbsoluteTimelinePosition,
   persistCurrentFrame: () => persistCurrentFrame,
   getInitialFrameState: () => getInitialFrameState,
-  getFrameForComposition: () => getFrameForComposition
+  getFrameForComposition: () => getFrameForComposition,
+  clampFrameToCompositionRange: () => clampFrameToCompositionRange
 });
 import { useContext as useContext10, useMemo as useMemo9 } from "react";
 
@@ -1509,6 +1510,9 @@ var getFrameForComposition = (composition) => {
   }
   return window.remotion_initialFrame ?? 0;
 };
+var clampFrameToCompositionRange = (frame, durationInFrames) => {
+  return Math.max(0, Math.min(Math.max(0, durationInFrames - 1), frame));
+};
 var useTimelinePositionFromContext = (state) => {
   const videoConfig = useVideo();
   const env = useRemotionEnvironment();
@@ -1516,7 +1520,7 @@ var useTimelinePositionFromContext = (state) => {
     return typeof window === "undefined" ? 0 : window.remotion_initialFrame ?? 0;
   }
   const unclamped = state.frame[videoConfig.id] ?? (env.isPlayer ? 0 : getFrameForComposition(videoConfig.id));
-  return Math.min(videoConfig.durationInFrames - 1, unclamped);
+  return clampFrameToCompositionRange(unclamped, videoConfig.durationInFrames);
 };
 var useTimelineContext = () => {
   const state = useContext10(TimelineContext);
@@ -1723,7 +1727,6 @@ var sequenceVisualStyleSchema = {
   },
   "style.scale": {
     type: "scale",
-    min: 0.05,
     max: 100,
     step: 0.01,
     default: 1,
@@ -1804,6 +1807,11 @@ var sequenceSchema = {
     }
   }
 };
+var sequenceSchemaWithoutFrom = {
+  hidden: hiddenField,
+  durationInFrames: durationInFramesField,
+  layout: sequenceSchema.layout
+};
 var sequenceSchemaDefaultLayoutNone = {
   ...sequenceSchema,
   layout: {
@@ -1824,11 +1832,17 @@ var SequenceManager = React11.createContext({
   },
   sequences: []
 });
+var SequenceManagerRefContext = React11.createContext({
+  current: []
+});
 var makeSequencePropsSubscriptionKey = (key) => {
   return `${key.nodePath.join(".")}.${key.sequenceKeys.join(".")}.${key.effectKeys.map((keys) => keys.join(".")).join(".")}`;
 };
-var VisualModeCodeValuesContext = React11.createContext({
-  codeValues: {}
+var VisualModePropStatusesContext = React11.createContext({
+  propStatuses: {}
+});
+var VisualModePropStatusesRefContext = React11.createContext({
+  current: {}
 });
 var VisualModeDragOverridesContext = React11.createContext({
   getDragOverrides: () => {
@@ -1851,18 +1865,22 @@ var VisualModeSettersContext = React11.createContext({
   clearEffectDragOverrides: () => {
     throw new Error("VisualModeSettersContext not initialized");
   },
-  setCodeValues: () => {
+  setPropStatuses: () => {
     throw new Error("VisualModeSettersContext not initialized");
   }
 });
 var effectDragOverridesKey = (nodePath, effectIndex) => `${makeSequencePropsSubscriptionKey(nodePath)}.effects.${effectIndex}`;
 var SequenceManagerProvider = ({ children }) => {
   const [sequences, setSequences] = useState3([]);
+  const sequencesRef = useRef4(sequences);
+  sequencesRef.current = sequences;
   const [dragOverrides, setControlOverrides] = useState3({});
   const controlOverridesRef = useRef4(dragOverrides);
   controlOverridesRef.current = dragOverrides;
   const [effectDragOverridesState, setEffectDragOverridesState] = useState3({});
-  const [codeValues, setCodeValuesMapState] = useState3({});
+  const [propStatuses, setPropStatusesMapState] = useState3({});
+  const propStatusesRef = useRef4(propStatuses);
+  propStatusesRef.current = propStatuses;
   const setDragOverrides = useCallback5((nodePath, key, value) => {
     setControlOverrides((prev) => ({
       ...prev,
@@ -1906,8 +1924,8 @@ var SequenceManagerProvider = ({ children }) => {
       return next;
     });
   }, []);
-  const setCodeValues = useCallback5((nodePath, values) => {
-    setCodeValuesMapState((prev) => {
+  const setPropStatuses = useCallback5((nodePath, values) => {
+    setPropStatusesMapState((prev) => {
       const key = makeSequencePropsSubscriptionKey(nodePath);
       const prevKey = prev[key];
       const newKey = values(prevKey);
@@ -1938,11 +1956,11 @@ var SequenceManagerProvider = ({ children }) => {
   const getEffectDragOverrides = useCallback5((nodePath, effectIndex) => {
     return effectDragOverridesState[effectDragOverridesKey(nodePath, effectIndex)] ?? {};
   }, [effectDragOverridesState]);
-  const codeValuesContext = useMemo12(() => {
+  const propStatusesContext = useMemo12(() => {
     return {
-      codeValues
+      propStatuses
     };
-  }, [codeValues]);
+  }, [propStatuses]);
   const dragOverridesContext = useMemo12(() => {
     return {
       getDragOverrides,
@@ -1955,24 +1973,30 @@ var SequenceManagerProvider = ({ children }) => {
       clearDragOverrides,
       setEffectDragOverrides,
       clearEffectDragOverrides,
-      setCodeValues
+      setPropStatuses
     };
   }, [
     setDragOverrides,
     clearDragOverrides,
     setEffectDragOverrides,
     clearEffectDragOverrides,
-    setCodeValues
+    setPropStatuses
   ]);
-  return /* @__PURE__ */ jsx10(SequenceManager.Provider, {
-    value: sequenceContext,
-    children: /* @__PURE__ */ jsx10(VisualModeCodeValuesContext.Provider, {
-      value: codeValuesContext,
-      children: /* @__PURE__ */ jsx10(VisualModeDragOverridesContext.Provider, {
-        value: dragOverridesContext,
-        children: /* @__PURE__ */ jsx10(VisualModeSettersContext.Provider, {
-          value: settersContext,
-          children
+  return /* @__PURE__ */ jsx10(SequenceManagerRefContext.Provider, {
+    value: sequencesRef,
+    children: /* @__PURE__ */ jsx10(SequenceManager.Provider, {
+      value: sequenceContext,
+      children: /* @__PURE__ */ jsx10(VisualModePropStatusesRefContext.Provider, {
+        value: propStatusesRef,
+        children: /* @__PURE__ */ jsx10(VisualModePropStatusesContext.Provider, {
+          value: propStatusesContext,
+          children: /* @__PURE__ */ jsx10(VisualModeDragOverridesContext.Provider, {
+            value: dragOverridesContext,
+            children: /* @__PURE__ */ jsx10(VisualModeSettersContext.Provider, {
+              value: settersContext,
+              children
+            })
+          })
         })
       })
     })
@@ -2483,6 +2507,40 @@ var interpolateString = ({
     dimensions
   });
 };
+var validateTupleOutputRange = (outputRange) => {
+  const dimensions = outputRange[0]?.length;
+  if (dimensions === undefined) {
+    throw new Error("outputRange must have at least 1 element");
+  }
+  if (dimensions === 0) {
+    throw new TypeError("outputRange tuples must contain at least 1 number");
+  }
+  for (const output of outputRange) {
+    if (output.length !== dimensions) {
+      throw new TypeError(`outputRange tuples must all have the same length, but got ${dimensions} and ${output.length}`);
+    }
+    for (const value of output) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`outputRange tuples must contain only finite numbers, but got [${output.join(",")}]`);
+      }
+    }
+  }
+  return dimensions;
+};
+var interpolateTuple = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const dimensions = validateTupleOutputRange(outputRange);
+  return new Array(dimensions).fill(true).map((_, axis) => interpolateNumber({
+    input,
+    inputRange,
+    outputRange: outputRange.map((output) => output[axis]),
+    options
+  }));
+};
 function checkValidInputRange(arr) {
   for (let i = 1;i < arr.length; ++i) {
     if (!(arr[i] > arr[i - 1])) {
@@ -2558,8 +2616,11 @@ function interpolate(input, inputRange, outputRange, options) {
     }
     return interpolateString({ input, inputRange, outputRange, options });
   }
+  if (outputRange.every((output) => Array.isArray(output))) {
+    return interpolateTuple({ input, inputRange, outputRange, options });
+  }
   if (!outputRange.every((output) => typeof output === "number")) {
-    throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
+    throw new TypeError("outputRange must contain only numbers, numeric tuples, or supported scale, translate, and rotate strings");
   }
   checkInfiniteRange("outputRange", outputRange);
   return interpolateNumber({ input, inputRange, outputRange, options });
@@ -3076,8 +3137,9 @@ var interpolateKeyframedStatus = ({
   if (keyframes.length === 0) {
     return null;
   }
-  const inputRange = keyframes.map((k) => k.frame);
-  const outputs = keyframes.map((k) => k.value);
+  const sortedKeyframes = [...keyframes].sort((a2, b2) => a2.frame - b2.frame);
+  const inputRange = sortedKeyframes.map((k) => k.frame);
+  const outputs = sortedKeyframes.map((k) => k.value);
   if (interpolationFunction === "interpolateColors") {
     if (!outputs.every((v) => typeof v === "string")) {
       return null;
@@ -3132,7 +3194,7 @@ var resolveDragOverrideValue = ({
   return { type: "resolved", value: interpolated };
 };
 var getEffectiveVisualModeValue = ({
-  codeValue,
+  propStatus,
   dragOverrideValue,
   defaultValue,
   frame = null,
@@ -3145,16 +3207,19 @@ var getEffectiveVisualModeValue = ({
   if (dragOverride.type === "resolved" && dragOverride.value !== undefined) {
     return dragOverride.value;
   }
-  if (codeValue.status === "keyframed" && frame !== null) {
-    return interpolateKeyframedStatus({
-      frame,
-      status: codeValue
-    });
+  if (propStatus.status === "keyframed") {
+    if (frame !== null) {
+      return interpolateKeyframedStatus({
+        frame,
+        status: propStatus
+      });
+    }
+    return shouldResortToDefaultValueIfUndefined ? defaultValue : undefined;
   }
-  if (codeValue.codeValue === undefined && shouldResortToDefaultValueIfUndefined) {
+  if (propStatus.codeValue === undefined && shouldResortToDefaultValueIfUndefined) {
     return defaultValue;
   }
-  return codeValue.codeValue;
+  return propStatus.codeValue;
 };
 
 // src/sequence-node-path.tsx
@@ -3171,18 +3236,18 @@ var OverrideIdsToNodePathsSettersContext = createContext16({
 // src/effects/use-memoized-effects.ts
 var mergeOverrides = ({
   descriptor,
-  codeOverrides,
+  propStatusOverrides,
   dragOverrides,
   frame
 }) => {
-  if (!codeOverrides && !dragOverrides) {
+  if (!propStatusOverrides && !dragOverrides) {
     return { params: descriptor.params, effectKey: descriptor.effectKey };
   }
   const merged = {
     ...descriptor.params
   };
-  if (codeOverrides) {
-    for (const [key, value] of Object.entries(codeOverrides)) {
+  if (propStatusOverrides) {
+    for (const [key, value] of Object.entries(propStatusOverrides)) {
       if (value !== undefined) {
         merged[key] = value;
       }
@@ -3204,16 +3269,27 @@ var mergeOverrides = ({
     effectKey: descriptor.definition.calculateKey(merged)
   };
 };
-var extractCodeOverrides = (propStatus) => {
+var resolvePropStatusOverrides = (propStatus, frame) => {
   if (!propStatus) {
     return null;
   }
   const out = {};
   let hasAny = false;
   for (const [key, status] of Object.entries(propStatus)) {
-    if (status.status !== "computed") {
+    if (status.status === "static") {
       out[key] = status.codeValue;
       hasAny = true;
+      continue;
+    }
+    if (status.status === "keyframed") {
+      const value = interpolateKeyframedStatus({
+        frame,
+        status
+      });
+      if (value !== null) {
+        out[key] = value;
+        hasAny = true;
+      }
     }
   }
   return hasAny ? out : null;
@@ -3229,12 +3305,12 @@ var useMemoizedEffectDefinitions = (effects) => {
   previousRef.current = definitions;
   return definitions;
 };
-var getEffectCodeValuesCtx = ({
-  codeValues,
+var getEffectPropStatusesCtx = ({
+  propStatuses,
   nodePath,
   effectIndex
 }) => {
-  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+  const status = propStatuses[makeSequencePropsSubscriptionKey(nodePath)];
   if (!status) {
     return { type: "cannot-update-sequence", reason: "not-found" };
   }
@@ -3250,8 +3326,8 @@ var getEffectCodeValuesCtx = ({
   }
   return { type: "can-update-effect", props: effect.props };
 };
-var getCodeValuesCtx = (codeValues, nodePath) => {
-  const status = codeValues[makeSequencePropsSubscriptionKey(nodePath)];
+var getPropStatusesCtx = (propStatuses, nodePath) => {
+  const status = propStatuses[makeSequencePropsSubscriptionKey(nodePath)];
   if (!status) {
     return;
   }
@@ -3265,7 +3341,7 @@ var useMemoizedEffects = ({
   overrideId
 }) => {
   const previousRef = useRef5(null);
-  const { codeValues } = useContext15(VisualModeCodeValuesContext);
+  const { propStatuses } = useContext15(VisualModePropStatusesContext);
   const { getEffectDragOverrides } = useContext15(VisualModeDragOverridesContext);
   const frame = useCurrentFrame();
   const { overrideIdToNodePathMappings } = useContext15(OverrideIdsToNodePathsGettersContext);
@@ -3279,17 +3355,17 @@ var useMemoizedEffects = ({
         effectKey: descriptor.effectKey
       };
     }
-    const effectStatus = getEffectCodeValuesCtx({
-      codeValues,
+    const effectStatus = getEffectPropStatusesCtx({
+      propStatuses,
       nodePath,
       effectIndex: index
     });
-    const codeOverrides = effectStatus.type === "can-update-effect" ? extractCodeOverrides(effectStatus.props) : null;
+    const propStatusOverrides = effectStatus.type === "can-update-effect" ? resolvePropStatusOverrides(effectStatus.props, frame) : null;
     const dragOverridesMap = getEffectDragOverrides(nodePath, index);
     const dragOverrides = Object.keys(dragOverridesMap).length === 0 ? null : dragOverridesMap;
     const { params, effectKey } = mergeOverrides({
       descriptor,
-      codeOverrides,
+      propStatusOverrides,
       dragOverrides,
       frame
     });
@@ -3447,15 +3523,15 @@ var computeEffectiveSchemaValuesDotNotation = ({
   const merged = {};
   const propsToDelete = new Set;
   for (const key of Object.keys(currentValue)) {
-    const codeValueStatus = propStatus?.[key] ?? null;
+    const status = propStatus?.[key] ?? null;
     const field = findFieldInSchema(schema, key);
     if (field?.type === "hidden") {
       continue;
     }
     let value;
-    if (codeValueStatus === null) {
+    if (status === null) {
       value = currentValue[key];
-    } else if (isKeyframedStatus(codeValueStatus)) {
+    } else if (isKeyframedStatus(status)) {
       if (field?.type === "array" || field?.keyframable === false) {
         value = currentValue[key];
       } else {
@@ -3468,18 +3544,18 @@ var computeEffectiveSchemaValuesDotNotation = ({
         } else if (frame !== null) {
           const interpolated = interpolateKeyframedStatus({
             frame,
-            status: codeValueStatus
+            status
           });
           value = interpolated ?? currentValue[key];
         } else {
           value = currentValue[key];
         }
       }
-    } else if (codeValueStatus.status === "computed") {
+    } else if (status.status === "computed") {
       value = currentValue[key];
     } else {
       value = getEffectiveVisualModeValue({
-        codeValue: codeValueStatus,
+        propStatus: status,
         dragOverrideValue: overrideValues[key],
         defaultValue: field?.default,
         frame,
@@ -3573,7 +3649,7 @@ var wrapInSchema = ({
         ref
       });
     }
-    const { codeValues } = useContext16(VisualModeCodeValuesContext);
+    const { propStatuses } = useContext16(VisualModePropStatusesContext);
     const { getDragOverrides } = useContext16(VisualModeDragOverridesContext);
     const nodePathMapping = useContext16(OverrideIdsToNodePathsGettersContext);
     const frame = useCurrentFrame();
@@ -3612,14 +3688,14 @@ var wrapInSchema = ({
         schema,
         currentValue: currentRuntimeValueDotNotation,
         overrideValues: nodePath === null ? {} : getDragOverrides(nodePath),
-        propStatus: nodePath === null ? undefined : getCodeValuesCtx(codeValues, nodePath),
+        propStatus: nodePath === null ? undefined : getPropStatusesCtx(propStatuses, nodePath),
         frame
       });
     }, [
       currentRuntimeValueDotNotation,
       getDragOverrides,
       nodePath,
-      codeValues,
+      propStatuses,
       frame
     ]);
     const activeKeys = selectActiveKeys(schema, valuesDotNotation);
@@ -3945,11 +4021,17 @@ var SequenceRefForwardingFunction = (props, ref) => {
   });
 };
 var SequenceInner = forwardRef3(SequenceRefForwardingFunction);
+var SequenceWithoutSchema = SequenceInner;
 var Sequence = wrapInSchema({
   Component: SequenceInner,
   schema: sequenceSchema,
   supportsEffects: false
 });
+var SequenceWithoutFrom = wrapInSchema({
+  Component: SequenceInner,
+  schema: sequenceSchemaWithoutFrom,
+  supportsEffects: false
+});
 // src/animated-image/AnimatedImage.tsx
 import {
   forwardRef as forwardRef4,
@@ -4918,7 +5000,7 @@ var calculateMediaDuration = ({
     duration -= trimBefore;
   }
   const actualDuration = duration / playbackRate;
-  return Math.floor(actualDuration);
+  return Number(actualDuration.toFixed(10));
 };
 
 // src/loop/index.tsx
@@ -10472,6 +10554,8 @@ function useRemotionContexts() {
   const resolveCompositionContext = React38.useContext(ResolveCompositionContext);
   const renderAssetManagerContext = React38.useContext(RenderAssetManager);
   const sequenceManagerContext = React38.useContext(SequenceManager);
+  const sequenceManagerRefContext = React38.useContext(SequenceManagerRefContext);
+  const visualModePropStatusesRefContext = React38.useContext(VisualModePropStatusesRefContext);
   const bufferManagerContext = React38.useContext(BufferingContextReact);
   const logLevelContext = React38.useContext(LogLevelContext);
   return useMemo37(() => ({
@@ -10485,6 +10569,8 @@ function useRemotionContexts() {
     resolveCompositionContext,
     renderAssetManagerContext,
     sequenceManagerContext,
+    sequenceManagerRefContext,
+    visualModePropStatusesRefContext,
     bufferManagerContext,
     logLevelContext
   }), [
@@ -10498,6 +10584,8 @@ function useRemotionContexts() {
     resolveCompositionContext,
     renderAssetManagerContext,
     sequenceManagerContext,
+    sequenceManagerRefContext,
+    visualModePropStatusesRefContext,
     bufferManagerContext,
     logLevelContext
   ]);
@@ -10514,21 +10602,27 @@ var RemotionContextProvider = (props2) => {
           value: contexts.preloadContext,
           children: /* @__PURE__ */ jsx35(CompositionManager.Provider, {
             value: contexts.compositionManagerCtx,
-            children: /* @__PURE__ */ jsx35(SequenceManager.Provider, {
-              value: contexts.sequenceManagerContext,
-              children: /* @__PURE__ */ jsx35(RenderAssetManager.Provider, {
-                value: contexts.renderAssetManagerContext,
-                children: /* @__PURE__ */ jsx35(ResolveCompositionContext.Provider, {
-                  value: contexts.resolveCompositionContext,
-                  children: /* @__PURE__ */ jsx35(TimelineContext.Provider, {
-                    value: contexts.timelineContext,
-                    children: /* @__PURE__ */ jsx35(SetTimelineContext.Provider, {
-                      value: contexts.setTimelineContext,
-                      children: /* @__PURE__ */ jsx35(SequenceContext.Provider, {
-                        value: contexts.sequenceContext,
-                        children: /* @__PURE__ */ jsx35(BufferingContextReact.Provider, {
-                          value: contexts.bufferManagerContext,
-                          children
+            children: /* @__PURE__ */ jsx35(SequenceManagerRefContext.Provider, {
+              value: contexts.sequenceManagerRefContext,
+              children: /* @__PURE__ */ jsx35(SequenceManager.Provider, {
+                value: contexts.sequenceManagerContext,
+                children: /* @__PURE__ */ jsx35(VisualModePropStatusesRefContext.Provider, {
+                  value: contexts.visualModePropStatusesRefContext,
+                  children: /* @__PURE__ */ jsx35(RenderAssetManager.Provider, {
+                    value: contexts.renderAssetManagerContext,
+                    children: /* @__PURE__ */ jsx35(ResolveCompositionContext.Provider, {
+                      value: contexts.resolveCompositionContext,
+                      children: /* @__PURE__ */ jsx35(TimelineContext.Provider, {
+                        value: contexts.timelineContext,
+                        children: /* @__PURE__ */ jsx35(SetTimelineContext.Provider, {
+                          value: contexts.setTimelineContext,
+                          children: /* @__PURE__ */ jsx35(SequenceContext.Provider, {
+                            value: contexts.sequenceContext,
+                            children: /* @__PURE__ */ jsx35(BufferingContextReact.Provider, {
+                              value: contexts.bufferManagerContext,
+                              children
+                            })
+                          })
                         })
                       })
                     })
@@ -10561,13 +10655,16 @@ var Internals = {
   VideoForPreview,
   CompositionManager,
   CompositionSetters,
-  VisualModeCodeValuesContext,
+  VisualModePropStatusesContext,
+  VisualModePropStatusesRefContext,
   VisualModeDragOverridesContext,
   VisualModeSettersContext,
   SequenceManager,
+  SequenceManagerRefContext,
   SequenceStackTracesUpdateContext,
   wrapInSchema,
   sequenceSchema,
+  SequenceWithoutSchema,
   sequenceStyleSchema,
   sequenceVisualStyleSchema,
   sequencePremountSchema,
@@ -10682,8 +10779,8 @@ var Internals = {
   OverrideIdsToNodePathsSettersContext,
   findPropsToDelete,
   makeSequencePropsSubscriptionKey,
-  getCodeValuesCtx,
-  getEffectCodeValuesCtx,
+  getPropStatusesCtx,
+  getEffectPropStatusesCtx,
   hiddenField,
   durationInFramesField,
   fromField
@@ -10742,6 +10839,7 @@ var SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
   });
 };
 var SeriesSequence = forwardRef13(SeriesSequenceRefForwardingFunction);
+var SequenceWithoutSchemaWithRef = SequenceWithoutSchema;
 var SeriesInner = (props2) => {
   const childrenValue = useMemo38(() => {
     let startFrame = 0;
@@ -10784,13 +10882,13 @@ var SeriesInner = (props2) => {
       }
       const currentStartFrame = startFrame + offset;
       startFrame += durationInFramesProp + offset;
-      return /* @__PURE__ */ jsx36(Sequence, {
+      return /* @__PURE__ */ jsx36(SequenceWithoutSchemaWithRef, {
+        ref: castedChild.ref,
         name: name || "<Series.Sequence>",
         _remotionInternalDocumentationLink: name ? undefined : "https://www.remotion.dev/docs/series",
         from: currentStartFrame,
         durationInFrames: durationInFramesProp,
         ...passedProps,
-        ref: castedChild.ref,
         children: child
       });
     });
@@ -10813,7 +10911,6 @@ var Series = Object.assign(wrapInSchema({
   Sequence: SeriesSequence
 });
 addSequenceStackTraces(Series);
-addSequenceStackTraces(SeriesSequence);
 // src/validation/validation-spring-duration.ts
 var validateSpringDuration = (dur) => {
   if (typeof dur === "undefined") {

package/dist/esm/no-react.mjs

@@ -252,6 +252,40 @@ var interpolateString = ({
     dimensions
   });
 };
+var validateTupleOutputRange = (outputRange) => {
+  const dimensions = outputRange[0]?.length;
+  if (dimensions === undefined) {
+    throw new Error("outputRange must have at least 1 element");
+  }
+  if (dimensions === 0) {
+    throw new TypeError("outputRange tuples must contain at least 1 number");
+  }
+  for (const output of outputRange) {
+    if (output.length !== dimensions) {
+      throw new TypeError(`outputRange tuples must all have the same length, but got ${dimensions} and ${output.length}`);
+    }
+    for (const value of output) {
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`outputRange tuples must contain only finite numbers, but got [${output.join(",")}]`);
+      }
+    }
+  }
+  return dimensions;
+};
+var interpolateTuple = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const dimensions = validateTupleOutputRange(outputRange);
+  return new Array(dimensions).fill(true).map((_, axis) => interpolateNumber({
+    input,
+    inputRange,
+    outputRange: outputRange.map((output) => output[axis]),
+    options
+  }));
+};
 function checkValidInputRange(arr) {
   for (let i = 1;i < arr.length; ++i) {
     if (!(arr[i] > arr[i - 1])) {
@@ -327,8 +361,11 @@ function interpolate(input, inputRange, outputRange, options) {
     }
     return interpolateString({ input, inputRange, outputRange, options });
   }
+  if (outputRange.every((output) => Array.isArray(output))) {
+    return interpolateTuple({ input, inputRange, outputRange, options });
+  }
   if (!outputRange.every((output) => typeof output === "number")) {
-    throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
+    throw new TypeError("outputRange must contain only numbers, numeric tuples, or supported scale, translate, and rotate strings");
   }
   checkInfiniteRange("outputRange", outputRange);
   return interpolateNumber({ input, inputRange, outputRange, options });
@@ -978,7 +1015,6 @@ var sequenceVisualStyleSchema = {
   },
   "style.scale": {
     type: "scale",
-    min: 0.05,
     max: 100,
     step: 0.01,
     default: 1,
@@ -1059,6 +1095,11 @@ var sequenceSchema = {
     }
   }
 };
+var sequenceSchemaWithoutFrom = {
+  hidden: hiddenField,
+  durationInFrames: durationInFramesField,
+  layout: sequenceSchema.layout
+};
 var sequenceSchemaDefaultLayoutNone = {
   ...sequenceSchema,
   layout: {

package/dist/esm/version.mjs

@@ -1,5 +1,5 @@
 // src/version.ts
-var VERSION = "4.0.472";
+var VERSION = "4.0.474";
 export {
   VERSION
 };