@remotion/vercel 4.0.471 → 4.0.472

package/dist/esm/index.mjs

@@ -115,6 +115,123 @@ import { statSync } from "fs";
 import { RenderInternals } from "@remotion/renderer";
 
 // ../core/dist/esm/no-react.mjs
+var normalizeNumber = (value) => {
+  return Math.round(value * 1e6) / 1e6;
+};
+var angleUnits = new Set(["deg", "rad", "grad", "turn"]);
+var lengthUnits = new Set([
+  "%",
+  "cap",
+  "ch",
+  "cm",
+  "cqb",
+  "cqh",
+  "cqi",
+  "cqmax",
+  "cqmin",
+  "cqw",
+  "dvh",
+  "dvw",
+  "em",
+  "ex",
+  "ic",
+  "in",
+  "lh",
+  "lvh",
+  "lvw",
+  "mm",
+  "pc",
+  "pt",
+  "px",
+  "q",
+  "rem",
+  "rlh",
+  "svh",
+  "svw",
+  "vb",
+  "vh",
+  "vi",
+  "vmax",
+  "vmin",
+  "vw"
+]);
+var cssNumberRegex = /^([+-]?(?:\\d+\\.?\\d*|\\.\\d+))([a-zA-Z%]+)?$/;
+var stringifyNumber = (value) => {
+  return String(normalizeNumber(value));
+};
+var parseStringInterpolationComponent = (component, value) => {
+  const match = cssNumberRegex.exec(component);
+  if (match === null) {
+    throw new TypeError(\`Cannot interpolate "\${value}" because "\${component}" is not a supported scale, translate, or rotate value\`);
+  }
+  const unit = match[2] ?? null;
+  const numberValue = Number(match[1]);
+  if (!Number.isFinite(numberValue)) {
+    throw new TypeError(\`Cannot interpolate "\${value}" because "\${component}" is not finite\`);
+  }
+  if (unit === null) {
+    return { kind: "scale", value: numberValue, unit: null };
+  }
+  if (angleUnits.has(unit)) {
+    return { kind: "rotate", value: numberValue, unit };
+  }
+  if (lengthUnits.has(unit)) {
+    return { kind: "translate", value: numberValue, unit };
+  }
+  throw new TypeError(\`Cannot interpolate "\${value}" because "\${unit}" is not a supported translate or rotate unit\`);
+};
+var parseStringInterpolationValue = (output) => {
+  if (typeof output === "number") {
+    if (!Number.isFinite(output)) {
+      throw new Error(\`outputRange must contain only finite numbers, but got [\${output}]\`);
+    }
+    return {
+      kind: "scale",
+      values: [output, output, 1],
+      units: [null, null, null],
+      dimensions: 1
+    };
+  }
+  const parts = output.trim().split(/\\s+/);
+  if (parts.length < 1 || parts.length > 3 || parts[0] === "") {
+    throw new TypeError(\`String outputRange values must contain 1 to 3 components, but got "\${output}"\`);
+  }
+  const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
+  const [{ kind }] = parsed;
+  for (const part of parsed) {
+    if (part.kind !== kind) {
+      throw new TypeError(\`Cannot interpolate "\${output}" because it mixes \${kind} and \${part.kind} values\`);
+    }
+  }
+  if (kind === "scale") {
+    const x = parsed[0].value;
+    const y = parsed[1]?.value ?? x;
+    const z = parsed[2]?.value ?? 1;
+    return {
+      kind,
+      values: [x, y, z],
+      units: [null, null, null],
+      dimensions: parsed.length
+    };
+  }
+  return {
+    kind,
+    values: [parsed[0].value, parsed[1]?.value ?? 0, parsed[2]?.value ?? 0],
+    units: [parsed[0].unit, parsed[1]?.unit ?? null, parsed[2]?.unit ?? null],
+    dimensions: parsed.length
+  };
+};
+var serializeStringInterpolationValue = ({
+  kind,
+  values,
+  units,
+  dimensions
+}) => {
+  if (kind === "scale") {
+    return values.slice(0, dimensions).map((value) => stringifyNumber(value)).join(" ");
+  }
+  return values.slice(0, dimensions).map((value, index) => \`\${stringifyNumber(value)}\${units[index]}\`).join(" ");
+};
 function interpolateFunction(input, inputRange, outputRange, options) {
   const { extrapolateLeft, extrapolateRight, easing } = options;
   let result = input;
@@ -159,6 +276,96 @@ function findRange(input, inputRange) {
   }
   return i - 1;
 }
+var defaultEasing = (num) => num;
+var interpolateNumber = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  if (inputRange.length === 1) {
+    return outputRange[0];
+  }
+  const easingOption = options?.easing;
+  const resolveEasingForSegment = (segmentIndex) => {
+    if (easingOption === undefined) {
+      return defaultEasing;
+    }
+    if (typeof easingOption === "function") {
+      return easingOption;
+    }
+    return easingOption[segmentIndex];
+  };
+  let extrapolateLeft = "extend";
+  if (options?.extrapolateLeft !== undefined) {
+    extrapolateLeft = options.extrapolateLeft;
+  }
+  let extrapolateRight = "extend";
+  if (options?.extrapolateRight !== undefined) {
+    extrapolateRight = options.extrapolateRight;
+  }
+  const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
+  const range = findRange(posterizedInput, inputRange);
+  return interpolateFunction(posterizedInput, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
+    easing: resolveEasingForSegment(range),
+    extrapolateLeft,
+    extrapolateRight
+  });
+};
+var interpolateString = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const parsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const kind = parsedOutputRange[0]?.kind;
+  if (kind === undefined) {
+    throw new Error("outputRange must have at least 1 element");
+  }
+  for (const parsed of parsedOutputRange) {
+    if (parsed.kind !== kind) {
+      throw new TypeError(\`Cannot interpolate \${kind} values with \${parsed.kind} values\`);
+    }
+  }
+  const dimensions = Math.max(...parsedOutputRange.map((parsed) => parsed.dimensions));
+  const units = [
+    null,
+    null,
+    null
+  ];
+  if (kind !== "scale") {
+    for (let axis = 0;axis < dimensions; axis++) {
+      for (const parsed of parsedOutputRange) {
+        const unit = parsed.units[axis];
+        if (unit === null) {
+          continue;
+        }
+        if (units[axis] === null) {
+          units[axis] = unit;
+          continue;
+        }
+        if (units[axis] !== unit) {
+          throw new TypeError(\`Cannot interpolate \${kind} values with different units on axis \${axis + 1}: \${units[axis]} and \${unit}\`);
+        }
+      }
+      if (units[axis] === null) {
+        throw new TypeError(\`Cannot interpolate \${kind} values because axis \${axis + 1} has no unit\`);
+      }
+    }
+  }
+  return serializeStringInterpolationValue({
+    kind,
+    values: [0, 0, 0].map((_, axis) => interpolateNumber({
+      input,
+      inputRange,
+      outputRange: parsedOutputRange.map((parsed) => parsed.values[axis]),
+      options
+    })),
+    units,
+    dimensions
+  });
+};
 function checkValidInputRange(arr) {
   for (let i = 1;i < arr.length; ++i) {
     if (!(arr[i] > arr[i - 1])) {
@@ -218,42 +425,27 @@ function interpolate(input, inputRange, outputRange, options) {
     throw new Error("inputRange (" + inputRange.length + ") and outputRange (" + outputRange.length + ") must have the same length");
   }
   checkInfiniteRange("inputRange", inputRange);
-  checkInfiniteRange("outputRange", outputRange);
   checkValidInputRange(inputRange);
   assertValidInterpolateEasingOption(options?.easing, inputRange.length);
   assertValidInterpolatePosterizeOption(options?.posterize);
-  const easingOption = options?.easing;
-  const defaultEasing = (num) => num;
-  const resolveEasingForSegment = (segmentIndex) => {
-    if (easingOption === undefined) {
-      return defaultEasing;
-    }
-    if (typeof easingOption === "function") {
-      return easingOption;
-    }
-    return easingOption[segmentIndex];
-  };
-  let extrapolateLeft = "extend";
-  if (options?.extrapolateLeft !== undefined) {
-    extrapolateLeft = options.extrapolateLeft;
-  }
-  let extrapolateRight = "extend";
-  if (options?.extrapolateRight !== undefined) {
-    extrapolateRight = options.extrapolateRight;
-  }
   if (typeof input !== "number") {
     throw new TypeError("Cannot interpolate an input which is not a number");
   }
-  if (inputRange.length === 1) {
-    return outputRange[0];
+  if (!Array.isArray(outputRange)) {
+    throw new Error("outputRange must contain only numbers");
   }
-  const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
-  const range = findRange(posterizedInput, inputRange);
-  return interpolateFunction(posterizedInput, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
-    easing: resolveEasingForSegment(range),
-    extrapolateLeft,
-    extrapolateRight
-  });
+  const hasStringOutput = outputRange.some((output) => typeof output === "string");
+  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");
+    }
+    return interpolateString({ 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");
+  }
+  checkInfiniteRange("outputRange", outputRange);
+  return interpolateNumber({ input, inputRange, outputRange, options });
 }
 function truthy(value) {
   return Boolean(value);
@@ -804,6 +996,45 @@ var proResProfileOptions = [
   "light",
   "proxy"
 ];
+var defaultScaleValue = [1, 1, 1];
+var parseScaleString = (value) => {
+  const parts = value.trim().split(/\\s+/);
+  if (parts.length < 1 || parts.length > 3 || parts[0] === "") {
+    return null;
+  }
+  const parsed = parts.map((part) => Number(part));
+  if (!parsed.every((part) => Number.isFinite(part))) {
+    return null;
+  }
+  const x = parsed[0];
+  const y = parsed[1] ?? x;
+  const z = parsed[2] ?? 1;
+  return [x, y, z];
+};
+var parseValidScaleValue = (value) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? [value, value, 1] : null;
+  }
+  if (typeof value === "string") {
+    return parseScaleString(value);
+  }
+  return null;
+};
+var parseScaleValue = (value) => {
+  return parseValidScaleValue(value) ?? defaultScaleValue;
+};
+var serializeScaleValue = ([x, y, z]) => {
+  const normalizedX = normalizeNumber(x);
+  const normalizedY = normalizeNumber(y);
+  const normalizedZ = normalizeNumber(z);
+  if (normalizedX === normalizedY && normalizedZ === 1) {
+    return normalizedX;
+  }
+  if (normalizedZ === 1) {
+    return \`\${normalizedX} \${normalizedY}\`;
+  }
+  return \`\${normalizedX} \${normalizedY} \${normalizedZ}\`;
+};
 var sequenceVisualStyleSchema = {
   "style.translate": {
     type: "translate",
@@ -812,7 +1043,7 @@ var sequenceVisualStyleSchema = {
     description: "Offset"
   },
   "style.scale": {
-    type: "number",
+    type: "scale",
     min: 0.05,
     max: 100,
     step: 0.01,
@@ -820,7 +1051,7 @@ var sequenceVisualStyleSchema = {
     description: "Scale"
   },
   "style.rotate": {
-    type: "rotation",
+    type: "rotation-css",
     step: 1,
     default: "0deg",
     description: "Rotation"
@@ -831,7 +1062,8 @@ var sequenceVisualStyleSchema = {
     max: 1,
     step: 0.01,
     default: 1,
-    description: "Opacity"
+    description: "Opacity",
+    hiddenFromList: false
   }
 };
 var sequencePremountSchema = {
@@ -840,10 +1072,15 @@ var sequencePremountSchema = {
     default: 0,
     description: "Premount For",
     min: 0,
-    step: 1
+    step: 1,
+    hiddenFromList: false
   },
   postmountFor: {
-    type: "hidden"
+    type: "number",
+    default: 0,
+    min: 0,
+    step: 1,
+    hiddenFromList: true
   },
   styleWhilePremounted: {
     type: "hidden"
@@ -861,8 +1098,23 @@ var hiddenField = {
   default: false,
   description: "Hidden"
 };
+var durationInFramesField = {
+  type: "number",
+  default: undefined,
+  min: 1,
+  step: 1,
+  hiddenFromList: true
+};
+var fromField = {
+  type: "number",
+  default: 0,
+  step: 1,
+  hiddenFromList: true
+};
 var sequenceSchema = {
   hidden: hiddenField,
+  from: fromField,
+  durationInFrames: durationInFramesField,
   layout: {
     type: "enum",
     default: "absolute-fill",
@@ -1044,7 +1296,9 @@ var NoReactInternals = {
   validateCodec,
   proResProfileOptions,
   findPropsToDelete,
-  sequenceSchema
+  sequenceSchema,
+  parseScaleValue,
+  serializeScaleValue
 };
 
 // src/scripts/render-still.ts
@@ -1159,6 +1413,123 @@ import { RenderInternals } from "@remotion/renderer";
 import { put } from "@vercel/blob";
 
 // ../core/dist/esm/no-react.mjs
+var normalizeNumber = (value) => {
+  return Math.round(value * 1e6) / 1e6;
+};
+var angleUnits = new Set(["deg", "rad", "grad", "turn"]);
+var lengthUnits = new Set([
+  "%",
+  "cap",
+  "ch",
+  "cm",
+  "cqb",
+  "cqh",
+  "cqi",
+  "cqmax",
+  "cqmin",
+  "cqw",
+  "dvh",
+  "dvw",
+  "em",
+  "ex",
+  "ic",
+  "in",
+  "lh",
+  "lvh",
+  "lvw",
+  "mm",
+  "pc",
+  "pt",
+  "px",
+  "q",
+  "rem",
+  "rlh",
+  "svh",
+  "svw",
+  "vb",
+  "vh",
+  "vi",
+  "vmax",
+  "vmin",
+  "vw"
+]);
+var cssNumberRegex = /^([+-]?(?:\\d+\\.?\\d*|\\.\\d+))([a-zA-Z%]+)?$/;
+var stringifyNumber = (value) => {
+  return String(normalizeNumber(value));
+};
+var parseStringInterpolationComponent = (component, value) => {
+  const match = cssNumberRegex.exec(component);
+  if (match === null) {
+    throw new TypeError(\`Cannot interpolate "\${value}" because "\${component}" is not a supported scale, translate, or rotate value\`);
+  }
+  const unit = match[2] ?? null;
+  const numberValue = Number(match[1]);
+  if (!Number.isFinite(numberValue)) {
+    throw new TypeError(\`Cannot interpolate "\${value}" because "\${component}" is not finite\`);
+  }
+  if (unit === null) {
+    return { kind: "scale", value: numberValue, unit: null };
+  }
+  if (angleUnits.has(unit)) {
+    return { kind: "rotate", value: numberValue, unit };
+  }
+  if (lengthUnits.has(unit)) {
+    return { kind: "translate", value: numberValue, unit };
+  }
+  throw new TypeError(\`Cannot interpolate "\${value}" because "\${unit}" is not a supported translate or rotate unit\`);
+};
+var parseStringInterpolationValue = (output) => {
+  if (typeof output === "number") {
+    if (!Number.isFinite(output)) {
+      throw new Error(\`outputRange must contain only finite numbers, but got [\${output}]\`);
+    }
+    return {
+      kind: "scale",
+      values: [output, output, 1],
+      units: [null, null, null],
+      dimensions: 1
+    };
+  }
+  const parts = output.trim().split(/\\s+/);
+  if (parts.length < 1 || parts.length > 3 || parts[0] === "") {
+    throw new TypeError(\`String outputRange values must contain 1 to 3 components, but got "\${output}"\`);
+  }
+  const parsed = parts.map((part) => parseStringInterpolationComponent(part, output));
+  const [{ kind }] = parsed;
+  for (const part of parsed) {
+    if (part.kind !== kind) {
+      throw new TypeError(\`Cannot interpolate "\${output}" because it mixes \${kind} and \${part.kind} values\`);
+    }
+  }
+  if (kind === "scale") {
+    const x = parsed[0].value;
+    const y = parsed[1]?.value ?? x;
+    const z = parsed[2]?.value ?? 1;
+    return {
+      kind,
+      values: [x, y, z],
+      units: [null, null, null],
+      dimensions: parsed.length
+    };
+  }
+  return {
+    kind,
+    values: [parsed[0].value, parsed[1]?.value ?? 0, parsed[2]?.value ?? 0],
+    units: [parsed[0].unit, parsed[1]?.unit ?? null, parsed[2]?.unit ?? null],
+    dimensions: parsed.length
+  };
+};
+var serializeStringInterpolationValue = ({
+  kind,
+  values,
+  units,
+  dimensions
+}) => {
+  if (kind === "scale") {
+    return values.slice(0, dimensions).map((value) => stringifyNumber(value)).join(" ");
+  }
+  return values.slice(0, dimensions).map((value, index) => \`\${stringifyNumber(value)}\${units[index]}\`).join(" ");
+};
 function interpolateFunction(input, inputRange, outputRange, options) {
   const { extrapolateLeft, extrapolateRight, easing } = options;
   let result = input;
@@ -1203,6 +1574,96 @@ function findRange(input, inputRange) {
   }
   return i - 1;
 }
+var defaultEasing = (num) => num;
+var interpolateNumber = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  if (inputRange.length === 1) {
+    return outputRange[0];
+  }
+  const easingOption = options?.easing;
+  const resolveEasingForSegment = (segmentIndex) => {
+    if (easingOption === undefined) {
+      return defaultEasing;
+    }
+    if (typeof easingOption === "function") {
+      return easingOption;
+    }
+    return easingOption[segmentIndex];
+  };
+  let extrapolateLeft = "extend";
+  if (options?.extrapolateLeft !== undefined) {
+    extrapolateLeft = options.extrapolateLeft;
+  }
+  let extrapolateRight = "extend";
+  if (options?.extrapolateRight !== undefined) {
+    extrapolateRight = options.extrapolateRight;
+  }
+  const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
+  const range = findRange(posterizedInput, inputRange);
+  return interpolateFunction(posterizedInput, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
+    easing: resolveEasingForSegment(range),
+    extrapolateLeft,
+    extrapolateRight
+  });
+};
+var interpolateString = ({
+  input,
+  inputRange,
+  outputRange,
+  options
+}) => {
+  const parsedOutputRange = outputRange.map(parseStringInterpolationValue);
+  const kind = parsedOutputRange[0]?.kind;
+  if (kind === undefined) {
+    throw new Error("outputRange must have at least 1 element");
+  }
+  for (const parsed of parsedOutputRange) {
+    if (parsed.kind !== kind) {
+      throw new TypeError(\`Cannot interpolate \${kind} values with \${parsed.kind} values\`);
+    }
+  }
+  const dimensions = Math.max(...parsedOutputRange.map((parsed) => parsed.dimensions));
+  const units = [
+    null,
+    null,
+    null
+  ];
+  if (kind !== "scale") {
+    for (let axis = 0;axis < dimensions; axis++) {
+      for (const parsed of parsedOutputRange) {
+        const unit = parsed.units[axis];
+        if (unit === null) {
+          continue;
+        }
+        if (units[axis] === null) {
+          units[axis] = unit;
+          continue;
+        }
+        if (units[axis] !== unit) {
+          throw new TypeError(\`Cannot interpolate \${kind} values with different units on axis \${axis + 1}: \${units[axis]} and \${unit}\`);
+        }
+      }
+      if (units[axis] === null) {
+        throw new TypeError(\`Cannot interpolate \${kind} values because axis \${axis + 1} has no unit\`);
+      }
+    }
+  }
+  return serializeStringInterpolationValue({
+    kind,
+    values: [0, 0, 0].map((_, axis) => interpolateNumber({
+      input,
+      inputRange,
+      outputRange: parsedOutputRange.map((parsed) => parsed.values[axis]),
+      options
+    })),
+    units,
+    dimensions
+  });
+};
 function checkValidInputRange(arr) {
   for (let i = 1;i < arr.length; ++i) {
     if (!(arr[i] > arr[i - 1])) {
@@ -1262,42 +1723,27 @@ function interpolate(input, inputRange, outputRange, options) {
     throw new Error("inputRange (" + inputRange.length + ") and outputRange (" + outputRange.length + ") must have the same length");
   }
   checkInfiniteRange("inputRange", inputRange);
-  checkInfiniteRange("outputRange", outputRange);
   checkValidInputRange(inputRange);
   assertValidInterpolateEasingOption(options?.easing, inputRange.length);
   assertValidInterpolatePosterizeOption(options?.posterize);
-  const easingOption = options?.easing;
-  const defaultEasing = (num) => num;
-  const resolveEasingForSegment = (segmentIndex) => {
-    if (easingOption === undefined) {
-      return defaultEasing;
-    }
-    if (typeof easingOption === "function") {
-      return easingOption;
-    }
-    return easingOption[segmentIndex];
-  };
-  let extrapolateLeft = "extend";
-  if (options?.extrapolateLeft !== undefined) {
-    extrapolateLeft = options.extrapolateLeft;
-  }
-  let extrapolateRight = "extend";
-  if (options?.extrapolateRight !== undefined) {
-    extrapolateRight = options.extrapolateRight;
-  }
   if (typeof input !== "number") {
     throw new TypeError("Cannot interpolate an input which is not a number");
   }
-  if (inputRange.length === 1) {
-    return outputRange[0];
+  if (!Array.isArray(outputRange)) {
+    throw new Error("outputRange must contain only numbers");
   }
-  const posterizedInput = options?.posterize === undefined ? input : Math.floor(input / options.posterize) * options.posterize;
-  const range = findRange(posterizedInput, inputRange);
-  return interpolateFunction(posterizedInput, [inputRange[range], inputRange[range + 1]], [outputRange[range], outputRange[range + 1]], {
-    easing: resolveEasingForSegment(range),
-    extrapolateLeft,
-    extrapolateRight
-  });
+  const hasStringOutput = outputRange.some((output) => typeof output === "string");
+  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");
+    }
+    return interpolateString({ 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");
+  }
+  checkInfiniteRange("outputRange", outputRange);
+  return interpolateNumber({ input, inputRange, outputRange, options });
 }
 function truthy(value) {
   return Boolean(value);
@@ -1848,6 +2294,45 @@ var proResProfileOptions = [
   "light",
   "proxy"
 ];
+var defaultScaleValue = [1, 1, 1];
+var parseScaleString = (value) => {
+  const parts = value.trim().split(/\\s+/);
+  if (parts.length < 1 || parts.length > 3 || parts[0] === "") {
+    return null;
+  }
+  const parsed = parts.map((part) => Number(part));
+  if (!parsed.every((part) => Number.isFinite(part))) {
+    return null;
+  }
+  const x = parsed[0];
+  const y = parsed[1] ?? x;
+  const z = parsed[2] ?? 1;
+  return [x, y, z];
+};
+var parseValidScaleValue = (value) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? [value, value, 1] : null;
+  }
+  if (typeof value === "string") {
+    return parseScaleString(value);
+  }
+  return null;
+};
+var parseScaleValue = (value) => {
+  return parseValidScaleValue(value) ?? defaultScaleValue;
+};
+var serializeScaleValue = ([x, y, z]) => {
+  const normalizedX = normalizeNumber(x);
+  const normalizedY = normalizeNumber(y);
+  const normalizedZ = normalizeNumber(z);
+  if (normalizedX === normalizedY && normalizedZ === 1) {
+    return normalizedX;
+  }
+  if (normalizedZ === 1) {
+    return \`\${normalizedX} \${normalizedY}\`;
+  }
+  return \`\${normalizedX} \${normalizedY} \${normalizedZ}\`;
+};
 var sequenceVisualStyleSchema = {
   "style.translate": {
     type: "translate",
@@ -1856,7 +2341,7 @@ var sequenceVisualStyleSchema = {
     description: "Offset"
   },
   "style.scale": {
-    type: "number",
+    type: "scale",
     min: 0.05,
     max: 100,
     step: 0.01,
@@ -1864,7 +2349,7 @@ var sequenceVisualStyleSchema = {
     description: "Scale"
   },
   "style.rotate": {
-    type: "rotation",
+    type: "rotation-css",
     step: 1,
     default: "0deg",
     description: "Rotation"
@@ -1875,7 +2360,8 @@ var sequenceVisualStyleSchema = {
     max: 1,
     step: 0.01,
     default: 1,
-    description: "Opacity"
+    description: "Opacity",
+    hiddenFromList: false
   }
 };
 var sequencePremountSchema = {
@@ -1884,10 +2370,15 @@ var sequencePremountSchema = {
     default: 0,
     description: "Premount For",
     min: 0,
-    step: 1
+    step: 1,
+    hiddenFromList: false
   },
   postmountFor: {
-    type: "hidden"
+    type: "number",
+    default: 0,
+    min: 0,
+    step: 1,
+    hiddenFromList: true
   },
   styleWhilePremounted: {
     type: "hidden"
@@ -1905,8 +2396,23 @@ var hiddenField = {
   default: false,
   description: "Hidden"
 };
+var durationInFramesField = {
+  type: "number",
+  default: undefined,
+  min: 1,
+  step: 1,
+  hiddenFromList: true
+};
+var fromField = {
+  type: "number",
+  default: 0,
+  step: 1,
+  hiddenFromList: true
+};
 var sequenceSchema = {
   hidden: hiddenField,
+  from: fromField,
+  durationInFrames: durationInFramesField,
   layout: {
     type: "enum",
     default: "absolute-fill",
@@ -2088,7 +2594,9 @@ var NoReactInternals = {
   validateCodec,
   proResProfileOptions,
   findPropsToDelete,
-  sequenceSchema
+  sequenceSchema,
+  parseScaleValue,
+  serializeScaleValue
 };
 
 // src/scripts/render-video.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/vercel",
-	"version": "4.0.471",
+	"version": "4.0.472",
 	"description": "Render Remotion videos on Vercel Sandbox",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -23,8 +23,8 @@
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"@remotion/renderer": "4.0.471",
-		"remotion": "4.0.471"
+		"@remotion/renderer": "4.0.472",
+		"remotion": "4.0.472"
 	},
 	"peerDependencies": {
 		"@vercel/sandbox": ">=1.0.0"
@@ -38,7 +38,7 @@
 		"./package.json": "./package.json"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.471",
+		"@remotion/eslint-config-internal": "4.0.472",
 		"@vercel/blob": "2.3.0",
 		"@vercel/sandbox": "1.6.0",
 		"eslint": "9.19.0",