remotion 4.0.526 → 4.0.527

package/dist/cjs/index.d.ts

@@ -5,7 +5,7 @@ import type { AnyCompMetadata, AnyComposition, AudioOrVideoAsset, JsxComponentId
 import type { DelayRenderScope } from './delay-render.js';
 import { type TFolder } from './Folder.js';
 import type { StaticFile } from './get-static-files.js';
-import type { AssetFieldSchema, ArrayFieldSchema, ArrayItemFieldSchema, CaptionsFieldSchema, InteractivitySchemaField, InteractivitySchema } from './interactivity-schema.js';
+import type { ArrayFieldSchema, ArrayItemFieldSchema, AssetFieldSchema, CaptionsFieldSchema, InteractivitySchema, InteractivitySchemaField } from './interactivity-schema.js';
 import type { LogLevel } from './log.js';
 import type { ProResProfile } from './prores-profile.js';
 import type { PixelFormat, VideoImageFormat } from './render-types.js';
@@ -135,7 +135,7 @@ export * from './internals.js';
 export { interpolateColors, type InterpolateColorsOptions, } from './interpolate-colors.js';
 export { LogLevel } from './log.js';
 export { Loop } from './loop/index.js';
-export { assertValidInterpolateEasingOption, assertValidInterpolatePosterizeOption, EasingFunction, ExtrapolateType, interpolate, InterpolateOutputOption, InterpolateOptions, random, RandomSeed, } from './no-react';
+export { assertValidInterpolateEasingOption, assertValidInterpolatePosterizeOption, EasingFunction, ExtrapolateType, interpolate, InterpolateOptions, InterpolateOutputOption, InterpolateOutputType, random, RandomSeed, } from './no-react';
 export { prefetch, PrefetchOnProgress } from './prefetch.js';
 export { registerRoot } from './register-root.js';
 export type { PixelFormat, VideoImageFormat } from './render-types.js';
@@ -184,4 +184,4 @@ export type _InternalTypes = {
     TRenderAsset: TRenderAsset;
     ProResProfile: ProResProfile;
 };
-export type { AnyComposition, AssetFieldSchema, ArrayFieldSchema, ArrayItemFieldSchema, CaptionsFieldSchema, DelayRenderScope, JsxComponentIdentity, LoopDisplay, RuntimeValueSnapshot, RuntimeValueStore, SequenceControls, SequenceRegistrationControls, InteractivitySchemaField, InteractivitySchema, UseBufferState, };
+export type { AnyComposition, ArrayFieldSchema, ArrayItemFieldSchema, AssetFieldSchema, CaptionsFieldSchema, DelayRenderScope, InteractivitySchema, InteractivitySchemaField, JsxComponentIdentity, LoopDisplay, RuntimeValueSnapshot, RuntimeValueStore, SequenceControls, SequenceRegistrationControls, UseBufferState, };

package/dist/cjs/interpolate.d.ts

@@ -1,5 +1,6 @@
 export type ExtrapolateType = 'extend' | 'identity' | 'clamp' | 'wrap';
 export type InterpolateOutputOption = 'linear' | 'perceptual-scale';
+export type InterpolateOutputType = 'font-weight' | 'scale' | 'translate' | 'rotate' | 'transform-origin';
 /**
  * @description This function allows you to map a range of values to another with a concise syntax
  * @see [Documentation](https://www.remotion.dev/docs/interpolate)
@@ -12,6 +13,7 @@ export type InterpolateOptions = Partial<{
     extrapolateLeft: ExtrapolateType;
     extrapolateRight: ExtrapolateType;
     output: InterpolateOutputOption;
+    outputType: InterpolateOutputType;
     posterize: number;
 }>;
 type NumericTuple = readonly [number, ...number[]];
@@ -21,6 +23,9 @@ type WidenNumericTuple<T extends readonly number[]> = {
 export declare function assertValidInterpolateEasingOption(easing: EasingFunction | readonly EasingFunction[] | undefined, inputRangeLength: number): void;
 export declare function assertValidInterpolatePosterizeOption(posterize: number | undefined): void;
 export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly number[], options?: InterpolateOptions): number;
+export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly (number | string)[], options: InterpolateOptions & {
+    outputType: 'font-weight';
+}): number;
 export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly string[], options?: InterpolateOptions): string;
 export declare function interpolate<const Tuple extends NumericTuple>(input: number, inputRange: readonly number[], outputRange: readonly Tuple[], options?: InterpolateOptions): WidenNumericTuple<Tuple>;
 export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly (readonly number[])[], options?: InterpolateOptions): number[];

package/dist/cjs/interpolate.js

@@ -254,7 +254,7 @@ const parseAxisRotationValue = (output) => {
         axisRotation: true,
     };
 };
-const parseStringInterpolationValue = (output) => {
+const parseStringInterpolationValue = (output, outputType) => {
     var _a, _b, _c, _d, _e, _f;
     var _g, _h, _j, _k, _l, _m;
     if (typeof output === 'number') {
@@ -269,8 +269,20 @@ const parseStringInterpolationValue = (output) => {
             axisRotation: false,
         };
     }
+    if (outputType === 'transform-origin') {
+        const transformOriginParts = output.trim().split(/\s+/);
+        if (transformOriginParts.length < 1 ||
+            transformOriginParts.length > 3 ||
+            transformOriginParts[0] === '') {
+            throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
+        }
+        return parseTransformOriginValue(output, transformOriginParts);
+    }
     const axisRotation = parseAxisRotationValue(output);
     if (axisRotation !== null) {
+        if (outputType !== undefined && outputType !== 'rotate') {
+            throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a rotate value`);
+        }
         return axisRotation;
     }
     const parts = output.trim().split(/\s+/);
@@ -278,6 +290,9 @@ const parseStringInterpolationValue = (output) => {
         throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
     }
     if (parts.some((part) => transformOriginKeywords.has(part.toLowerCase()))) {
+        if (outputType !== undefined) {
+            throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a transform-origin value`);
+        }
         return parseTransformOriginValue(output, parts);
     }
     const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
@@ -287,6 +302,9 @@ const parseStringInterpolationValue = (output) => {
             throw new TypeError(`Cannot interpolate "${output}" because it mixes ${kind} and ${part.kind} values`);
         }
     }
+    if (outputType !== undefined && outputType !== kind) {
+        throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a ${kind} value`);
+    }
     if (kind === 'scale') {
         const x = parsed[0].value;
         const y = (_g = (_a = parsed[1]) === null || _a === void 0 ? void 0 : _a.value) !== null && _g !== void 0 ? _g : x;
@@ -486,9 +504,9 @@ const interpolateNumber = ({ input, inputRange, outputRange, options, }) => {
     }
     return result;
 };
-const interpolateString = ({ input, inputRange, outputRange, options, }) => {
+const interpolateString = ({ input, inputRange, outputRange, options, outputType, }) => {
     var _a;
-    const initiallyParsedOutputRange = outputRange.map(parseStringInterpolationValue);
+    const initiallyParsedOutputRange = outputRange.map((output) => parseStringInterpolationValue(output, outputType));
     const hasAxisRotation = initiallyParsedOutputRange.some((parsed) => parsed.axisRotation);
     const posterizedInput = (options === null || options === void 0 ? void 0 : options.posterize) === undefined
         ? input
@@ -589,6 +607,35 @@ const interpolateString = ({ input, inputRange, outputRange, options, }) => {
         axisRotation: hasAxisRotation,
     });
 };
+const interpolateFontWeight = ({ input, inputRange, outputRange, options, }) => {
+    const normalizedOutputRange = outputRange.map((output) => {
+        if (typeof output === 'string') {
+            const lowerCaseOutput = output.toLowerCase();
+            if (lowerCaseOutput === 'normal') {
+                return 400;
+            }
+            if (lowerCaseOutput === 'bold') {
+                return 700;
+            }
+        }
+        const match = typeof output === 'string' ? cssNumberRegex.exec(output) : null;
+        const value = typeof output === 'number'
+            ? output
+            : match !== null && match[2] === undefined
+                ? Number(match[1])
+                : Number.NaN;
+        if (!Number.isFinite(value) || value < 1 || value > 1000) {
+            throw new TypeError(`Cannot interpolate font weight "${output}". Expected "normal", "bold", or a number between 1 and 1000`);
+        }
+        return value;
+    });
+    return interpolateNumber({
+        input,
+        inputRange,
+        outputRange: normalizedOutputRange,
+        options,
+    });
+};
 const interpolateDiscreteString = ({ input, inputRange, outputRange, options, }) => {
     if (inputRange.length === 1) {
         return outputRange[0];
@@ -725,6 +772,17 @@ function assertValidInterpolateOutputOption(output) {
     }
     throw new Error(`output must be "linear" or "perceptual-scale", but got ${String(output)}`);
 }
+function assertValidInterpolateOutputType(outputType) {
+    if (outputType === undefined ||
+        outputType === 'font-weight' ||
+        outputType === 'scale' ||
+        outputType === 'translate' ||
+        outputType === 'rotate' ||
+        outputType === 'transform-origin') {
+        return;
+    }
+    throw new Error(`outputType must be "font-weight", "scale", "translate", "rotate", or "transform-origin", but got ${String(outputType)}`);
+}
 function interpolate(input, inputRange, outputRange, options) {
     if (typeof input === 'undefined') {
         throw new Error('input can not be undefined');
@@ -747,19 +805,41 @@ function interpolate(input, inputRange, outputRange, options) {
     assertValidInterpolateEasingOption(options === null || options === void 0 ? void 0 : options.easing, inputRange.length);
     assertValidInterpolatePosterizeOption(options === null || options === void 0 ? void 0 : options.posterize);
     assertValidInterpolateOutputOption(options === null || options === void 0 ? void 0 : options.output);
+    assertValidInterpolateOutputType(options === null || options === void 0 ? void 0 : options.outputType);
     if (typeof input !== 'number') {
         throw new TypeError('Cannot interpolate an input which is not a number');
     }
     if (!Array.isArray(outputRange)) {
         throw new Error('outputRange must contain only numbers');
     }
+    const outputType = options === null || options === void 0 ? void 0 : options.outputType;
+    if (outputType === 'font-weight') {
+        if (!outputRange.every((output) => typeof output === 'number' || typeof output === 'string')) {
+            throw new TypeError('Font weight outputRange must contain only numbers or strings');
+        }
+        return interpolateFontWeight({
+            input,
+            inputRange,
+            outputRange,
+            options,
+        });
+    }
     const hasStringOutput = outputRange.some((output) => typeof output === 'string');
+    if (outputType !== undefined && outputType !== 'scale' && !hasStringOutput) {
+        throw new TypeError(`${outputType} outputRange must contain strings with the appropriate CSS units`);
+    }
     if (hasStringOutput) {
         if (!outputRange.every((output) => typeof output === 'string' || typeof output === 'number')) {
             throw new TypeError('outputRange must contain only numbers, or supported scale, translate, and rotate strings');
         }
         try {
-            return interpolateString({ input, inputRange, outputRange, options });
+            return interpolateString({
+                input,
+                inputRange,
+                outputRange,
+                options,
+                outputType,
+            });
         }
         catch (error) {
             if (!outputRange.every((output) => typeof output === 'string')) {
@@ -767,7 +847,7 @@ function interpolate(input, inputRange, outputRange, options) {
             }
             const hasNonNumericString = outputRange.some((output) => {
                 try {
-                    parseStringInterpolationValue(output);
+                    parseStringInterpolationValue(output, outputType);
                     return false;
                 }
                 catch (parseError) {

package/dist/cjs/no-react.d.ts

@@ -1,7 +1,7 @@
 export type { ArtifactAsset, AudioOrVideoAsset, InlineAudioAsset, TRenderAsset, } from './CompositionManager';
 export type { DownloadBehavior } from './download-behavior';
 export { assertValidInterpolateEasingOption, assertValidInterpolatePosterizeOption, interpolate, } from './interpolate';
-export type { EasingFunction, ExtrapolateType, InterpolateOutputOption, InterpolateOptions, } from './interpolate';
+export type { EasingFunction, ExtrapolateType, InterpolateOptions, InterpolateOutputOption, InterpolateOutputType, } from './interpolate';
 export { random } from './random.js';
 export type { RandomSeed } from './random.js';
 export type { VideoConfig } from './video-config';

package/dist/cjs/spring/spring-utils.js

@@ -64,15 +64,24 @@ function advance({ animation, now, config, }) {
 }
 const calculationCache = {};
 function springCalculation({ frame, fps, config = {}, }) {
+    var _a, _b, _c, _d;
     const from = 0;
     const to = 1;
+    // An explicit `undefined` (e.g. a forwarded optional prop) must not
+    // override the defaults, otherwise the physics turn into NaN
+    const resolvedConfig = {
+        damping: (_a = config.damping) !== null && _a !== void 0 ? _a : defaultSpringConfig.damping,
+        mass: (_b = config.mass) !== null && _b !== void 0 ? _b : defaultSpringConfig.mass,
+        stiffness: (_c = config.stiffness) !== null && _c !== void 0 ? _c : defaultSpringConfig.stiffness,
+        overshootClamping: (_d = config.overshootClamping) !== null && _d !== void 0 ? _d : defaultSpringConfig.overshootClamping,
+    };
     const cacheKey = [
         frame,
         fps,
-        config.damping,
-        config.mass,
-        config.overshootClamping,
-        config.stiffness,
+        resolvedConfig.damping,
+        resolvedConfig.mass,
+        resolvedConfig.overshootClamping,
+        resolvedConfig.stiffness,
     ].join('-');
     if (calculationCache[cacheKey]) {
         return calculationCache[cacheKey];
@@ -91,20 +100,14 @@ function springCalculation({ frame, fps, config = {}, }) {
         animation = advance({
             animation,
             now: time,
-            config: {
-                ...defaultSpringConfig,
-                ...config,
-            },
+            config: resolvedConfig,
         });
     }
     if (unevenRest > 0) {
         animation = advance({
             animation,
             now: (frameClamped / fps) * 1000,
-            config: {
-                ...defaultSpringConfig,
-                ...config,
-            },
+            config: resolvedConfig,
         });
     }
     calculationCache[cacheKey] = animation;

package/dist/cjs/version.d.ts

@@ -3,4 +3,4 @@
  * @see [Documentation](https://remotion.dev/docs/version)
  * @returns {string} The current version of the remotion package
  */
-export declare const VERSION = "4.0.526";
+export declare const VERSION = "4.0.527";

package/dist/cjs/version.js

@@ -7,4 +7,4 @@ exports.VERSION = void 0;
  * @see [Documentation](https://remotion.dev/docs/version)
  * @returns {string} The current version of the remotion package
  */
-exports.VERSION = '4.0.526';
+exports.VERSION = '4.0.527';

package/dist/esm/index.mjs

@@ -1537,7 +1537,7 @@ var Composition = (props) => {
 };
 
 // src/version.ts
-var VERSION = "4.0.526";
+var VERSION = "4.0.527";
 
 // src/multiple-versions-warning.ts
 var checkMultipleRemotionVersions = () => {
@@ -3226,7 +3226,7 @@ var parseAxisRotationValue = (output) => {
     axisRotation: true
   };
 };
-var parseStringInterpolationValue = (output) => {
+var parseStringInterpolationValue = (output, outputType) => {
   if (typeof output === "number") {
     if (!Number.isFinite(output)) {
       throw new Error(`outputRange must contain only finite numbers, but got [${output}]`);
@@ -3239,8 +3239,18 @@ var parseStringInterpolationValue = (output) => {
       axisRotation: false
     };
   }
+  if (outputType === "transform-origin") {
+    const transformOriginParts = output.trim().split(/\s+/);
+    if (transformOriginParts.length < 1 || transformOriginParts.length > 3 || transformOriginParts[0] === "") {
+      throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
+    }
+    return parseTransformOriginValue(output, transformOriginParts);
+  }
   const axisRotation = parseAxisRotationValue(output);
   if (axisRotation !== null) {
+    if (outputType !== undefined && outputType !== "rotate") {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a rotate value`);
+    }
     return axisRotation;
   }
   const parts = output.trim().split(/\s+/);
@@ -3248,6 +3258,9 @@ var parseStringInterpolationValue = (output) => {
     throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
   }
   if (parts.some((part) => transformOriginKeywords.has(part.toLowerCase()))) {
+    if (outputType !== undefined) {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a transform-origin value`);
+    }
     return parseTransformOriginValue(output, parts);
   }
   const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
@@ -3257,6 +3270,9 @@ var parseStringInterpolationValue = (output) => {
       throw new TypeError(`Cannot interpolate "${output}" because it mixes ${kind} and ${part.kind} values`);
     }
   }
+  if (outputType !== undefined && outputType !== kind) {
+    throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a ${kind} value`);
+  }
   if (kind === "scale") {
     const x = parsed[0].value;
     const y = parsed[1]?.value ?? x;
@@ -3457,9 +3473,10 @@ var interpolateString = ({
   input,
   inputRange,
   outputRange,
-  options
+  options,
+  outputType
 }) => {
-  const initiallyParsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const initiallyParsedOutputRange = outputRange.map((output) => parseStringInterpolationValue(output, outputType));
   const hasAxisRotation = initiallyParsedOutputRange.some((parsed) => parsed.axisRotation);
   const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
   const segmentIndex = inputRange.length === 1 ? 0 : findRange(posterizedInput, inputRange);
@@ -3539,6 +3556,36 @@ var interpolateString = ({
     axisRotation: hasAxisRotation
   });
 };
+var interpolateFontWeight = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const normalizedOutputRange = outputRange.map((output) => {
+    if (typeof output === "string") {
+      const lowerCaseOutput = output.toLowerCase();
+      if (lowerCaseOutput === "normal") {
+        return 400;
+      }
+      if (lowerCaseOutput === "bold") {
+        return 700;
+      }
+    }
+    const match = typeof output === "string" ? cssNumberRegex.exec(output) : null;
+    const value = typeof output === "number" ? output : match !== null && match[2] === undefined ? Number(match[1]) : Number.NaN;
+    if (!Number.isFinite(value) || value < 1 || value > 1000) {
+      throw new TypeError(`Cannot interpolate font weight "${output}". Expected "normal", "bold", or a number between 1 and 1000`);
+    }
+    return value;
+  });
+  return interpolateNumber({
+    input,
+    inputRange,
+    outputRange: normalizedOutputRange,
+    options
+  });
+};
 var interpolateDiscreteString = ({
   input,
   inputRange,
@@ -3670,6 +3717,12 @@ function assertValidInterpolateOutputOption(output) {
   }
   throw new Error(`output must be "linear" or "perceptual-scale", but got ${String(output)}`);
 }
+function assertValidInterpolateOutputType(outputType) {
+  if (outputType === undefined || outputType === "font-weight" || outputType === "scale" || outputType === "translate" || outputType === "rotate" || outputType === "transform-origin") {
+    return;
+  }
+  throw new Error(`outputType must be "font-weight", "scale", "translate", "rotate", or "transform-origin", but got ${String(outputType)}`);
+}
 function interpolate(input, inputRange, outputRange, options) {
   if (typeof input === "undefined") {
     throw new Error("input can not be undefined");
@@ -3688,26 +3741,48 @@ function interpolate(input, inputRange, outputRange, options) {
   assertValidInterpolateEasingOption(options?.easing, inputRange.length);
   assertValidInterpolatePosterizeOption(options?.posterize);
   assertValidInterpolateOutputOption(options?.output);
+  assertValidInterpolateOutputType(options?.outputType);
   if (typeof input !== "number") {
     throw new TypeError("Cannot interpolate an input which is not a number");
   }
   if (!Array.isArray(outputRange)) {
     throw new Error("outputRange must contain only numbers");
   }
+  const outputType = options?.outputType;
+  if (outputType === "font-weight") {
+    if (!outputRange.every((output) => typeof output === "number" || typeof output === "string")) {
+      throw new TypeError("Font weight outputRange must contain only numbers or strings");
+    }
+    return interpolateFontWeight({
+      input,
+      inputRange,
+      outputRange,
+      options
+    });
+  }
   const hasStringOutput = outputRange.some((output) => typeof output === "string");
+  if (outputType !== undefined && outputType !== "scale" && !hasStringOutput) {
+    throw new TypeError(`${outputType} outputRange must contain strings with the appropriate CSS units`);
+  }
   if (hasStringOutput) {
     if (!outputRange.every((output) => typeof output === "string" || typeof output === "number")) {
       throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
     }
     try {
-      return interpolateString({ input, inputRange, outputRange, options });
+      return interpolateString({
+        input,
+        inputRange,
+        outputRange,
+        options,
+        outputType
+      });
     } catch (error2) {
       if (!outputRange.every((output) => typeof output === "string")) {
         throw error2;
       }
       const hasNonNumericString = outputRange.some((output) => {
         try {
-          parseStringInterpolationValue(output);
+          parseStringInterpolationValue(output, outputType);
           return false;
         } catch (parseError) {
           return parseError instanceof UnsupportedStringInterpolationValueError;
@@ -3846,13 +3921,19 @@ function springCalculation({
 }) {
   const from = 0;
   const to = 1;
+  const resolvedConfig = {
+    damping: config.damping ?? defaultSpringConfig.damping,
+    mass: config.mass ?? defaultSpringConfig.mass,
+    stiffness: config.stiffness ?? defaultSpringConfig.stiffness,
+    overshootClamping: config.overshootClamping ?? defaultSpringConfig.overshootClamping
+  };
   const cacheKey = [
     frame,
     fps,
-    config.damping,
-    config.mass,
-    config.overshootClamping,
-    config.stiffness
+    resolvedConfig.damping,
+    resolvedConfig.mass,
+    resolvedConfig.overshootClamping,
+    resolvedConfig.stiffness
   ].join("-");
   if (calculationCache[cacheKey]) {
     return calculationCache[cacheKey];
@@ -3871,20 +3952,14 @@ function springCalculation({
     animation = advance({
       animation,
       now: time,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   if (unevenRest > 0) {
     animation = advance({
       animation,
       now: frameClamped / fps * 1000,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   calculationCache[cacheKey] = animation;

package/dist/esm/no-react.mjs

@@ -237,13 +237,19 @@ function springCalculation({
 }) {
   const from = 0;
   const to = 1;
+  const resolvedConfig = {
+    damping: config.damping ?? defaultSpringConfig.damping,
+    mass: config.mass ?? defaultSpringConfig.mass,
+    stiffness: config.stiffness ?? defaultSpringConfig.stiffness,
+    overshootClamping: config.overshootClamping ?? defaultSpringConfig.overshootClamping
+  };
   const cacheKey = [
     frame,
     fps,
-    config.damping,
-    config.mass,
-    config.overshootClamping,
-    config.stiffness
+    resolvedConfig.damping,
+    resolvedConfig.mass,
+    resolvedConfig.overshootClamping,
+    resolvedConfig.stiffness
   ].join("-");
   if (calculationCache[cacheKey]) {
     return calculationCache[cacheKey];
@@ -262,20 +268,14 @@ function springCalculation({
     animation = advance({
       animation,
       now: time,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   if (unevenRest > 0) {
     animation = advance({
       animation,
       now: frameClamped / fps * 1000,
-      config: {
-        ...defaultSpringConfig,
-        ...config
-      }
+      config: resolvedConfig
     });
   }
   calculationCache[cacheKey] = animation;
@@ -750,7 +750,7 @@ var parseAxisRotationValue = (output) => {
     axisRotation: true
   };
 };
-var parseStringInterpolationValue = (output) => {
+var parseStringInterpolationValue = (output, outputType) => {
   if (typeof output === "number") {
     if (!Number.isFinite(output)) {
       throw new Error(`outputRange must contain only finite numbers, but got [${output}]`);
@@ -763,8 +763,18 @@ var parseStringInterpolationValue = (output) => {
       axisRotation: false
     };
   }
+  if (outputType === "transform-origin") {
+    const transformOriginParts = output.trim().split(/\s+/);
+    if (transformOriginParts.length < 1 || transformOriginParts.length > 3 || transformOriginParts[0] === "") {
+      throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
+    }
+    return parseTransformOriginValue(output, transformOriginParts);
+  }
   const axisRotation = parseAxisRotationValue(output);
   if (axisRotation !== null) {
+    if (outputType !== undefined && outputType !== "rotate") {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a rotate value`);
+    }
     return axisRotation;
   }
   const parts = output.trim().split(/\s+/);
@@ -772,6 +782,9 @@ var parseStringInterpolationValue = (output) => {
     throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
   }
   if (parts.some((part) => transformOriginKeywords.has(part.toLowerCase()))) {
+    if (outputType !== undefined) {
+      throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a transform-origin value`);
+    }
     return parseTransformOriginValue(output, parts);
   }
   const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
@@ -781,6 +794,9 @@ var parseStringInterpolationValue = (output) => {
       throw new TypeError(`Cannot interpolate "${output}" because it mixes ${kind} and ${part.kind} values`);
     }
   }
+  if (outputType !== undefined && outputType !== kind) {
+    throw new TypeError(`Cannot interpolate "${output}" as ${outputType} because it is a ${kind} value`);
+  }
   if (kind === "scale") {
     const x = parsed[0].value;
     const y = parsed[1]?.value ?? x;
@@ -981,9 +997,10 @@ var interpolateString = ({
   input,
   inputRange,
   outputRange,
-  options
+  options,
+  outputType
 }) => {
-  const initiallyParsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const initiallyParsedOutputRange = outputRange.map((output) => parseStringInterpolationValue(output, outputType));
   const hasAxisRotation = initiallyParsedOutputRange.some((parsed) => parsed.axisRotation);
   const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
   const segmentIndex = inputRange.length === 1 ? 0 : findRange(posterizedInput, inputRange);
@@ -1063,6 +1080,36 @@ var interpolateString = ({
     axisRotation: hasAxisRotation
   });
 };
+var interpolateFontWeight = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const normalizedOutputRange = outputRange.map((output) => {
+    if (typeof output === "string") {
+      const lowerCaseOutput = output.toLowerCase();
+      if (lowerCaseOutput === "normal") {
+        return 400;
+      }
+      if (lowerCaseOutput === "bold") {
+        return 700;
+      }
+    }
+    const match = typeof output === "string" ? cssNumberRegex.exec(output) : null;
+    const value = typeof output === "number" ? output : match !== null && match[2] === undefined ? Number(match[1]) : Number.NaN;
+    if (!Number.isFinite(value) || value < 1 || value > 1000) {
+      throw new TypeError(`Cannot interpolate font weight "${output}". Expected "normal", "bold", or a number between 1 and 1000`);
+    }
+    return value;
+  });
+  return interpolateNumber({
+    input,
+    inputRange,
+    outputRange: normalizedOutputRange,
+    options
+  });
+};
 var interpolateDiscreteString = ({
   input,
   inputRange,
@@ -1194,6 +1241,12 @@ function assertValidInterpolateOutputOption(output) {
   }
   throw new Error(`output must be "linear" or "perceptual-scale", but got ${String(output)}`);
 }
+function assertValidInterpolateOutputType(outputType) {
+  if (outputType === undefined || outputType === "font-weight" || outputType === "scale" || outputType === "translate" || outputType === "rotate" || outputType === "transform-origin") {
+    return;
+  }
+  throw new Error(`outputType must be "font-weight", "scale", "translate", "rotate", or "transform-origin", but got ${String(outputType)}`);
+}
 function interpolate(input, inputRange, outputRange, options) {
   if (typeof input === "undefined") {
     throw new Error("input can not be undefined");
@@ -1212,26 +1265,48 @@ function interpolate(input, inputRange, outputRange, options) {
   assertValidInterpolateEasingOption(options?.easing, inputRange.length);
   assertValidInterpolatePosterizeOption(options?.posterize);
   assertValidInterpolateOutputOption(options?.output);
+  assertValidInterpolateOutputType(options?.outputType);
   if (typeof input !== "number") {
     throw new TypeError("Cannot interpolate an input which is not a number");
   }
   if (!Array.isArray(outputRange)) {
     throw new Error("outputRange must contain only numbers");
   }
+  const outputType = options?.outputType;
+  if (outputType === "font-weight") {
+    if (!outputRange.every((output) => typeof output === "number" || typeof output === "string")) {
+      throw new TypeError("Font weight outputRange must contain only numbers or strings");
+    }
+    return interpolateFontWeight({
+      input,
+      inputRange,
+      outputRange,
+      options
+    });
+  }
   const hasStringOutput = outputRange.some((output) => typeof output === "string");
+  if (outputType !== undefined && outputType !== "scale" && !hasStringOutput) {
+    throw new TypeError(`${outputType} outputRange must contain strings with the appropriate CSS units`);
+  }
   if (hasStringOutput) {
     if (!outputRange.every((output) => typeof output === "string" || typeof output === "number")) {
       throw new TypeError("outputRange must contain only numbers, or supported scale, translate, and rotate strings");
     }
     try {
-      return interpolateString({ input, inputRange, outputRange, options });
+      return interpolateString({
+        input,
+        inputRange,
+        outputRange,
+        options,
+        outputType
+      });
     } catch (error) {
       if (!outputRange.every((output) => typeof output === "string")) {
         throw error;
       }
       const hasNonNumericString = outputRange.some((output) => {
         try {
-          parseStringInterpolationValue(output);
+          parseStringInterpolationValue(output, outputType);
           return false;
         } catch (parseError) {
           return parseError instanceof UnsupportedStringInterpolationValueError;

package/dist/esm/version.mjs

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

package/package.json

@@ -3,7 +3,7 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/core"
 	},
 	"name": "remotion",
-	"version": "4.0.526",
+	"version": "4.0.527",
 	"description": "Make videos programmatically",
 	"main": "dist/cjs/index.js",
 	"types": "dist/cjs/index.d.ts",
@@ -35,7 +35,7 @@
 		"react-dom": "19.2.3",
 		"webpack": "5.105.0",
 		"zod": "4.5.4",
-		"@remotion/eslint-config-internal": "4.0.526",
+		"@remotion/eslint-config-internal": "4.0.527",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},

package/dist/cjs/nonce.d.ts

@@ -1,11 +0,0 @@
-export type TNonceContext = {
-    getNonce: () => number;
-};
-type NonceHistoryItem = [number, number];
-export type NonceHistory = NonceHistoryItem[];
-export type NonceHistoryContext = {
-    get: () => NonceHistory;
-};
-export declare const NonceContext: import("react").Context<TNonceContext>;
-export declare const useNonce: () => NonceHistoryContext;
-export {};

package/dist/cjs/nonce.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useNonce = exports.NonceContext = void 0;
-const react_1 = require("react");
-exports.NonceContext = (0, react_1.createContext)({
-    getNonce: () => 0,
-});
-let fastRefreshNonce = 0;
-try {
-    if (typeof __webpack_module__ !== 'undefined') {
-        if (__webpack_module__.hot) {
-            __webpack_module__.hot.addStatusHandler((status) => {
-                if (status === 'idle') {
-                    fastRefreshNonce++;
-                }
-            });
-        }
-    }
-}
-catch (_a) {
-    // __webpack_module__ may throw ReferenceError in some environments
-}
-const useNonce = () => {
-    const context = (0, react_1.useContext)(exports.NonceContext);
-    const nonce = context.getNonce();
-    const nonceRef = (0, react_1.useRef)(nonce);
-    nonceRef.current = nonce;
-    const history = (0, react_1.useRef)([[fastRefreshNonce, nonce]]);
-    const get = (0, react_1.useCallback)(() => {
-        if (fastRefreshNonce !== history.current[history.current.length - 1][0]) {
-            history.current = [
-                ...history.current,
-                [fastRefreshNonce, nonceRef.current],
-            ];
-        }
-        return history.current;
-    }, [history]);
-    return (0, react_1.useMemo)(() => {
-        return { get };
-    }, [get]);
-};
-exports.useNonce = useNonce;