@remotion/studio-server 4.0.513 → 4.0.514

package/dist/codemods/update-keyframes/update-keyframes.js

@@ -1,1307 +1,16 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateEffectKeyframes = exports.updateEffectKeyframesAst = exports.updateSequenceKeyframes = exports.updateSequenceKeyframesAst = void 0;
-const studio_shared_1 = require("@remotion/studio-shared");
-const recast = __importStar(require("recast"));
-const get_ast_node_path_1 = require("../../helpers/get-ast-node-path");
-const parse_keyframe_easing_expression_1 = require("../../helpers/parse-keyframe-easing-expression");
-const video_config_numeric_expression_1 = require("../../helpers/video-config-numeric-expression");
-const video_config_values_1 = require("../../helpers/video-config-values");
-const can_update_sequence_props_1 = require("../../preview-server/routes/can-update-sequence-props");
+exports.updateEffectKeyframes = exports.updateSequenceKeyframes = exports.updateSequenceKeyframesAst = exports.updateEffectKeyframesAst = void 0;
+const studio_codemods_1 = require("@remotion/studio-codemods");
 const format_file_content_1 = require("../format-file-content");
-const parse_ast_1 = require("../parse-ast");
-const update_effect_props_1 = require("../update-effect-props/update-effect-props");
-const update_nested_prop_1 = require("../update-nested-prop");
-const ensure_imports_and_frame_hook_1 = require("./ensure-imports-and-frame-hook");
-const b = recast.types.builders;
-const getObjectPropertyNameFromUpdateKey = (key) => {
-    const dotIndex = key.indexOf('.');
-    return dotIndex === -1 ? key : key.slice(dotIndex + 1);
-};
-const lineStartsWithPropertyName = ({ line, propertyName, }) => {
-    const trimmed = line.trimStart();
-    return (trimmed.startsWith(`${propertyName}:`) ||
-        trimmed.startsWith(`'${propertyName}':`) ||
-        trimmed.startsWith(`"${propertyName}":`));
-};
-const getIndent = (line) => {
-    var _a;
-    var _b;
-    return (_b = (_a = line.match(/^[ \t]*/)) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : '';
-};
-const removeBlankLinesFromObjectsWithProperties = ({ input, propertyNames, }) => {
-    if (propertyNames.length === 0) {
-        return input;
-    }
-    const lines = input.split('\n');
-    const linesToRemove = new Set();
-    for (let i = 0; i < lines.length; i++) {
-        const propertyName = propertyNames.find((name) => lineStartsWithPropertyName({ line: lines[i], propertyName: name }));
-        if (!propertyName) {
-            continue;
-        }
-        const propertyIndentLength = getIndent(lines[i]).length;
-        let objectStart = i;
-        for (let j = i - 1; j >= 0; j--) {
-            const trimmed = lines[j].trim();
-            if (trimmed.endsWith('{') &&
-                getIndent(lines[j]).length < propertyIndentLength) {
-                objectStart = j;
-                break;
-            }
-        }
-        let objectEnd = i;
-        for (let j = i + 1; j < lines.length; j++) {
-            const trimmed = lines[j].trim();
-            if (trimmed.startsWith('}') &&
-                getIndent(lines[j]).length < propertyIndentLength) {
-                objectEnd = j;
-                break;
-            }
-        }
-        for (let j = objectStart + 1; j < objectEnd; j++) {
-            if (lines[j].trim() === '') {
-                linesToRemove.add(j);
-            }
-        }
-    }
-    if (linesToRemove.size === 0) {
-        return input;
-    }
-    return lines.filter((_, index) => !linesToRemove.has(index)).join('\n');
-};
-const getSupportedCallArgument = (arg) => {
-    if (arg === undefined ||
-        arg.type === 'ArgumentPlaceholder' ||
-        arg.type === 'JSXNamespacedName') {
-        return null;
-    }
-    return arg;
-};
-const getInterpolationExpression = (node, videoConfigValues) => {
-    if (node.type === 'TSAsExpression') {
-        return getInterpolationExpression(node.expression, videoConfigValues);
-    }
-    if (node.type !== 'CallExpression' ||
-        node.callee.type !== 'Identifier' ||
-        !(0, studio_shared_1.isKeyframeInterpolationFunction)(node.callee.name)) {
-        return null;
-    }
-    const frameArg = getSupportedCallArgument(node.arguments[0]);
-    const inputArg = node.arguments[1];
-    const outputArg = node.arguments[2];
-    if (!frameArg ||
-        !inputArg ||
-        !outputArg ||
-        inputArg.type !== 'ArrayExpression' ||
-        outputArg.type !== 'ArrayExpression' ||
-        inputArg.elements.length !== outputArg.elements.length) {
-        return null;
-    }
-    const keyframes = [];
-    for (let i = 0; i < inputArg.elements.length; i++) {
-        const inputElement = inputArg.elements[i];
-        const outputElement = outputArg.elements[i];
-        if (!inputElement ||
-            !outputElement ||
-            inputElement.type === 'SpreadElement' ||
-            outputElement.type === 'SpreadElement') {
-            return null;
-        }
-        const frameExpression = (0, video_config_numeric_expression_1.parseVideoConfigNumericExpression)({
-            node: inputElement,
-            videoConfigValues,
-        });
-        if (frameExpression === null || !(0, can_update_sequence_props_1.isStaticValue)(outputElement)) {
-            return null;
-        }
-        keyframes.push({
-            frame: frameExpression.value,
-            frameExpression: inputElement,
-            frameNumericExpression: frameExpression,
-            originalFrame: frameExpression.value,
-            output: outputElement,
-            value: (0, can_update_sequence_props_1.extractStaticValue)(outputElement),
-        });
-    }
-    if (keyframes.length === 0) {
-        return null;
-    }
-    const extraArgs = [];
-    for (const arg of node.arguments.slice(3)) {
-        const supportedArg = getSupportedCallArgument(arg);
-        if (!supportedArg) {
-            return null;
-        }
-        extraArgs.push(supportedArg);
-    }
-    return {
-        callee: node.callee,
-        input: frameArg,
-        extraArgs,
-        keyframes,
-    };
-};
-const getInterpolationCalleeForValues = ({ schema, key, staticValue, newValue, }) => {
-    return b.identifier((0, studio_shared_1.getKeyframeInterpolationFunction)({
-        schema,
-        key,
-        staticValue,
-        newValue,
-    }));
-};
-const createFrameExpression = (frame) => {
-    return (0, update_nested_prop_1.parseValueExpression)(frame);
-};
-const createClampOptionsExpression = ({ defaultOutput, }) => {
-    const properties = [
-        b.objectProperty(b.identifier('extrapolateLeft'), b.stringLiteral('clamp')),
-        b.objectProperty(b.identifier('extrapolateRight'), b.stringLiteral('clamp')),
-    ];
-    if (defaultOutput !== null && defaultOutput !== 'linear') {
-        properties.push(b.objectProperty(b.identifier('output'), b.stringLiteral(defaultOutput)));
-    }
-    return b.objectExpression(properties);
-};
-const createEmptyOptionsExpression = () => b.objectExpression([]);
-const findObjectOptionProperty = (options, propertyName) => {
-    const propIndex = options.properties.findIndex((prop) => prop.type === 'ObjectProperty' &&
-        !prop.computed &&
-        ((prop.key.type === 'Identifier' && prop.key.name === propertyName) ||
-            (prop.key.type === 'StringLiteral' && prop.key.value === propertyName)));
-    return {
-        propIndex,
-        prop: propIndex === -1
-            ? undefined
-            : options.properties[propIndex],
-    };
-};
-const setOptionsProperty = ({ options, propertyName, value, }) => {
-    const { propIndex, prop } = findObjectOptionProperty(options, propertyName);
-    if (value === null) {
-        if (propIndex !== -1) {
-            options.properties.splice(propIndex, 1);
-        }
-        return;
-    }
-    if (prop) {
-        prop.value = value;
-        return;
-    }
-    options.properties.push(b.objectProperty(b.identifier(propertyName), value));
-};
-const isLinearEasing = (easing) => easing.type === 'linear';
-const getKeyframeEasing = (node) => (0, parse_keyframe_easing_expression_1.parseKeyframeEasingExpression)(node);
-const getKeyframeEasingArray = ({ easingNode, segmentCount, }) => {
-    if (segmentCount === 0) {
-        return [];
-    }
-    if (easingNode.type === 'TSAsExpression') {
-        return getKeyframeEasingArray({
-            easingNode: easingNode.expression,
-            segmentCount,
-        });
-    }
-    if (easingNode.type === 'ArrayExpression') {
-        if (easingNode.elements.length > segmentCount) {
-            return null;
-        }
-        const parsed = easingNode.elements.map((element) => {
-            if (!element || element.type === 'SpreadElement') {
-                return null;
-            }
-            return getKeyframeEasing(element);
-        });
-        if (parsed.some((value) => value === null)) {
-            return null;
-        }
-        const easingArray = parsed;
-        while (easingArray.length < segmentCount) {
-            easingArray.push(studio_shared_1.LINEAR_KEYFRAME_EASING);
-        }
-        return easingArray;
-    }
-    const easing = getKeyframeEasing(easingNode);
-    if (!easing) {
-        return null;
-    }
-    return new Array(segmentCount).fill(easing);
-};
-const getExistingEasingArray = ({ options, segmentCount, }) => {
-    const { prop } = findObjectOptionProperty(options, 'easing');
-    if (!prop) {
-        return Array.from({ length: segmentCount }, () => ({ type: 'linear' }));
-    }
-    const easing = getKeyframeEasingArray({
-        easingNode: prop.value,
-        segmentCount,
-    });
-    if (!easing) {
-        throw new Error('Cannot update easing: easing must be inline');
-    }
-    return easing;
-};
-const getExistingEasingArrayOrNull = ({ options, segmentCount, }) => {
-    const { prop } = findObjectOptionProperty(options, 'easing');
-    if (!prop) {
-        return null;
-    }
-    return getExistingEasingArray({ options, segmentCount });
-};
-const createEasingExpression = (easing) => {
-    switch (easing.type) {
-        case 'linear':
-            return b.memberExpression(b.identifier('Easing'), b.identifier('linear'));
-        case 'step1':
-            return b.memberExpression(b.identifier('Easing'), b.identifier('step1'));
-        case 'spring':
-            return b.callExpression(b.memberExpression(b.identifier('Easing'), b.identifier('spring')), [
-                b.objectExpression([
-                    b.objectProperty(b.identifier('damping'), (0, update_nested_prop_1.parseValueExpression)(easing.damping)),
-                    b.objectProperty(b.identifier('mass'), (0, update_nested_prop_1.parseValueExpression)(easing.mass)),
-                    b.objectProperty(b.identifier('stiffness'), (0, update_nested_prop_1.parseValueExpression)(easing.stiffness)),
-                    ...(easing.allowTail === null
-                        ? []
-                        : [
-                            b.objectProperty(b.identifier('allowTail'), b.booleanLiteral(easing.allowTail)),
-                        ]),
-                    ...(easing.durationRestThreshold === null
-                        ? []
-                        : [
-                            b.objectProperty(b.identifier('durationRestThreshold'), (0, update_nested_prop_1.parseValueExpression)(easing.durationRestThreshold)),
-                        ]),
-                    b.objectProperty(b.identifier('overshootClamping'), b.booleanLiteral(easing.overshootClamping)),
-                ]),
-            ]);
-        case 'bezier':
-            return b.callExpression(b.memberExpression(b.identifier('Easing'), b.identifier('bezier')), [easing.x1, easing.y1, easing.x2, easing.y2].map((value) => (0, update_nested_prop_1.parseValueExpression)(value)));
-        default:
-            throw new Error(`Unsupported easing: ${JSON.stringify(easing)}`);
-    }
-};
-const createEasingArrayExpression = (easing) => b.arrayExpression(easing.map((easingValue) => createEasingExpression(easingValue)));
-const setEasingOption = ({ options, easing, }) => {
-    const hasNonLinearEasing = easing.some((easingValue) => !isLinearEasing(easingValue));
-    setOptionsProperty({
-        options,
-        propertyName: 'easing',
-        value: hasNonLinearEasing ? createEasingArrayExpression(easing) : null,
-    });
-    return hasNonLinearEasing;
-};
-const getExtraArgsWithOptions = ({ extraArgs, options, }) => {
-    return options.properties.length === 0
-        ? extraArgs.slice(1)
-        : [options, ...extraArgs.slice(1)];
-};
-const getInlineOptionsFromExtraArgs = (extraArgs) => {
-    const existingOptions = extraArgs[0];
-    if (!existingOptions || existingOptions.type !== 'ObjectExpression') {
-        return null;
-    }
-    return existingOptions;
-};
-const normalizeEasingAfterAddingKeyframe = ({ extraArgs, previousSegmentCount, nextSegmentCount, insertedKeyframeIndex, nextKeyframeCount, defaultEasing, }) => {
-    var _a, _b;
-    const options = (_a = getInlineOptionsFromExtraArgs(extraArgs)) !== null && _a !== void 0 ? _a : (extraArgs.length === 0 ? createEmptyOptionsExpression() : null);
-    if (!options) {
-        return { extraArgs, needsEasingImport: false };
-    }
-    const easing = (_b = getExistingEasingArrayOrNull({
-        options,
-        segmentCount: previousSegmentCount,
-    })) !== null && _b !== void 0 ? _b : Array.from({ length: previousSegmentCount }, () => defaultEasing);
-    if (easing.length < nextSegmentCount) {
-        const isSplittingExistingSegment = insertedKeyframeIndex > 0 &&
-            insertedKeyframeIndex < nextKeyframeCount - 1;
-        const easingIndexToDuplicate = isSplittingExistingSegment && easing.length > 0
-            ? Math.min(insertedKeyframeIndex - 1, easing.length - 1)
-            : null;
-        easing.splice(insertedKeyframeIndex, 0, easingIndexToDuplicate === null
-            ? defaultEasing
-            : easing[easingIndexToDuplicate]);
-    }
-    while (easing.length < nextSegmentCount) {
-        easing.push(defaultEasing);
-    }
-    const needsEasingImport = setEasingOption({ options, easing });
-    return {
-        extraArgs: getExtraArgsWithOptions({ extraArgs, options }),
-        needsEasingImport,
-    };
-};
-const getEasingIndexToRemove = ({ removedKeyframeIndex, keyframeCountBeforeRemoval, }) => {
-    if (removedKeyframeIndex === 0) {
-        return 0;
-    }
-    if (removedKeyframeIndex === keyframeCountBeforeRemoval - 1) {
-        return removedKeyframeIndex - 1;
-    }
-    return removedKeyframeIndex;
-};
-const normalizeEasingAfterRemovingKeyframe = ({ extraArgs, previousSegmentCount, nextSegmentCount, removedKeyframeIndex, }) => {
-    const options = getInlineOptionsFromExtraArgs(extraArgs);
-    if (!options) {
-        return { extraArgs, needsEasingImport: false };
-    }
-    const easing = getExistingEasingArrayOrNull({
-        options,
-        segmentCount: previousSegmentCount,
-    });
-    if (easing === null) {
-        return { extraArgs, needsEasingImport: false };
-    }
-    if (easing.length > 0) {
-        const easingIndexToRemove = getEasingIndexToRemove({
-            removedKeyframeIndex,
-            keyframeCountBeforeRemoval: previousSegmentCount + 1,
-        });
-        easing.splice(easingIndexToRemove, 1);
-    }
-    while (easing.length > nextSegmentCount) {
-        easing.pop();
-    }
-    while (easing.length < nextSegmentCount) {
-        easing.push(studio_shared_1.LINEAR_KEYFRAME_EASING);
-    }
-    return {
-        extraArgs: getExtraArgsWithOptions({ extraArgs, options }),
-        needsEasingImport: setEasingOption({ options, easing }),
-    };
-};
-const normalizeEasingAfterRemovingKeyframes = ({ extraArgs, previousSegmentCount, nextSegmentCount, removedKeyframeIndexes, }) => {
-    const options = getInlineOptionsFromExtraArgs(extraArgs);
-    if (!options) {
-        return { extraArgs, needsEasingImport: false };
-    }
-    const easing = getExistingEasingArrayOrNull({
-        options,
-        segmentCount: previousSegmentCount,
-    });
-    if (easing === null) {
-        return { extraArgs, needsEasingImport: false };
-    }
-    for (const { removedKeyframeIndex, keyframeCountBeforeRemoval } of [
-        ...removedKeyframeIndexes,
-    ]
-        .sort((first, second) => second - first)
-        .map((keyframeIndex, index) => ({
-        removedKeyframeIndex: keyframeIndex,
-        keyframeCountBeforeRemoval: previousSegmentCount + 1 - index,
-    }))) {
-        if (easing.length === 0) {
-            break;
-        }
-        const easingIndexToRemove = getEasingIndexToRemove({
-            removedKeyframeIndex,
-            keyframeCountBeforeRemoval,
-        });
-        easing.splice(easingIndexToRemove, 1);
-    }
-    while (easing.length > nextSegmentCount) {
-        easing.pop();
-    }
-    while (easing.length < nextSegmentCount) {
-        easing.push(studio_shared_1.LINEAR_KEYFRAME_EASING);
-    }
-    return {
-        extraArgs: getExtraArgsWithOptions({ extraArgs, options }),
-        needsEasingImport: setEasingOption({ options, easing }),
-    };
-};
-const validatePosterize = (posterize) => {
-    if (posterize === undefined) {
-        return;
-    }
-    if (!Number.isFinite(posterize) || posterize <= 0) {
-        throw new Error('Cannot update keyframe settings: posterize must be > 0');
-    }
-};
-const validateOutput = (output) => {
-    if (output === undefined ||
-        output === 'linear' ||
-        output === 'perceptual-scale') {
-        return;
-    }
-    throw new Error('Cannot update keyframe settings: output must be "linear" or "perceptual-scale"');
-};
-const updateKeyframeSettings = ({ expression, clamping, posterize, output, videoConfigValues, }) => {
-    validatePosterize(posterize);
-    validateOutput(output);
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    if (!existing) {
-        throw new Error('Cannot update keyframe settings on non-keyframed value');
-    }
-    const calleeName = existing.callee.type === 'Identifier' ? existing.callee.name : null;
-    const isColorInterpolation = calleeName === 'interpolateColors';
-    const extraArgs = [...existing.extraArgs];
-    const existingOptions = extraArgs[0];
-    if (existingOptions && existingOptions.type !== 'ObjectExpression') {
-        throw new Error('Cannot update keyframe settings: options must be inline');
-    }
-    const options = (existingOptions === null || existingOptions === void 0 ? void 0 : existingOptions.type) === 'ObjectExpression'
-        ? existingOptions
-        : createEmptyOptionsExpression();
-    if (isColorInterpolation) {
-        setOptionsProperty({ options, propertyName: 'extrapolateLeft', value: null });
-        setOptionsProperty({
-            options,
-            propertyName: 'extrapolateRight',
-            value: null,
-        });
-        setOptionsProperty({ options, propertyName: 'output', value: null });
-    }
-    else if (clamping) {
-        setOptionsProperty({
-            options,
-            propertyName: 'extrapolateLeft',
-            value: b.stringLiteral(clamping.left),
-        });
-        setOptionsProperty({
-            options,
-            propertyName: 'extrapolateRight',
-            value: b.stringLiteral(clamping.right),
-        });
-    }
-    if (!isColorInterpolation && output !== undefined) {
-        setOptionsProperty({
-            options,
-            propertyName: 'output',
-            value: output === 'linear' ? null : b.stringLiteral(output),
-        });
-    }
-    setOptionsProperty({
-        options,
-        propertyName: 'posterize',
-        value: posterize === undefined ? null : b.numericLiteral(posterize),
-    });
-    const nextExtraArgs = options.properties.length === 0
-        ? extraArgs.slice(1)
-        : [options, ...extraArgs.slice(1)];
-    return createInterpolateExpression({
-        callee: existing.callee,
-        input: existing.input,
-        extraArgs: nextExtraArgs,
-        keyframes: existing.keyframes,
-    });
-};
-const updateKeyframeEasing = ({ expression, segmentIndex, easing, videoConfigValues, }) => {
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    if (!existing) {
-        throw new Error('Cannot update easing on non-keyframed value');
-    }
-    const segmentCount = Math.max(0, existing.keyframes.length - 1);
-    if (!Number.isInteger(segmentIndex) ||
-        segmentIndex < 0 ||
-        segmentIndex >= segmentCount) {
-        throw new Error('Cannot update easing: segment index out of range');
-    }
-    const extraArgs = [...existing.extraArgs];
-    const existingOptions = extraArgs[0];
-    if (existingOptions && existingOptions.type !== 'ObjectExpression') {
-        throw new Error('Cannot update easing: options must be inline');
-    }
-    const options = (existingOptions === null || existingOptions === void 0 ? void 0 : existingOptions.type) === 'ObjectExpression'
-        ? existingOptions
-        : createEmptyOptionsExpression();
-    const nextEasing = getExistingEasingArray({ options, segmentCount });
-    nextEasing[segmentIndex] = easing;
-    const hasNonLinearEasing = nextEasing.some((easingValue) => !isLinearEasing(easingValue));
-    setOptionsProperty({
-        options,
-        propertyName: 'easing',
-        value: hasNonLinearEasing ? createEasingArrayExpression(nextEasing) : null,
-    });
-    const nextExtraArgs = options.properties.length === 0
-        ? extraArgs.slice(1)
-        : [options, ...extraArgs.slice(1)];
-    return {
-        expression: createInterpolateExpression({
-            callee: existing.callee,
-            input: existing.input,
-            extraArgs: nextExtraArgs,
-            keyframes: existing.keyframes,
-        }),
-        needsEasingImport: hasNonLinearEasing,
-    };
-};
-const createInterpolateExpression = ({ callee, input, extraArgs, keyframes, }) => {
-    const sortedKeyframes = [...keyframes].sort((first, second) => first.frame - second.frame);
-    return b.callExpression(callee, [
-        input,
-        b.arrayExpression(sortedKeyframes.map((keyframe) => keyframe.frame === keyframe.originalFrame
-            ? keyframe.frameExpression
-            : (0, video_config_numeric_expression_1.updateVideoConfigNumericExpression)({
-                expression: keyframe.frameNumericExpression,
-                value: keyframe.frame,
-            }))),
-        b.arrayExpression(sortedKeyframes.map((keyframe) => keyframe.output)),
-        ...extraArgs,
-    ]);
-};
-const noIntroducedIdentifiers = {
-    calleeName: null,
-    needsFrameHook: false,
-    needsEasingImport: false,
-};
-const addKeyframe = ({ expression, key, frame, value, schema, videoConfigValues, }) => {
-    var _a;
-    if (!(0, studio_shared_1.isSchemaFieldKeyframable)({ schema, key })) {
-        throw new Error(`Cannot add keyframe: "${key}" is not keyframable`);
-    }
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    const newOutput = (0, update_nested_prop_1.parseValueExpression)(value);
-    if (existing) {
-        const defaultEasing = (0, studio_shared_1.isSchemaFieldHoldOnly)({ schema, key })
-            ? studio_shared_1.HOLD_KEYFRAME_EASING
-            : studio_shared_1.LINEAR_KEYFRAME_EASING;
-        const existingCalleeName = existing.callee.type === 'Identifier'
-            ? existing.callee.name
-            : 'interpolate';
-        const schemaCalleeName = (0, studio_shared_1.getKeyframeInterpolationFunctionForSchemaField)({
-            schema,
-            key,
-        });
-        const nextCalleeName = schemaCalleeName !== null && schemaCalleeName !== void 0 ? schemaCalleeName : existingCalleeName;
-        const existingIndex = existing.keyframes.findIndex((keyframe) => keyframe.frame === frame);
-        const nextKeyframes = existingIndex === -1
-            ? [
-                ...existing.keyframes,
-                {
-                    frame,
-                    frameExpression: createFrameExpression(frame),
-                    frameNumericExpression: { type: 'literal', value: frame },
-                    originalFrame: frame,
-                    output: newOutput,
-                    value,
-                },
-            ]
-            : existing.keyframes.map((keyframe, index) => index === existingIndex
-                ? { ...keyframe, output: newOutput, value }
-                : keyframe);
-        const normalizedEasing = existingIndex === -1
-            ? normalizeEasingAfterAddingKeyframe({
-                extraArgs: existing.extraArgs,
-                previousSegmentCount: Math.max(existing.keyframes.length - 1, 0),
-                nextSegmentCount: Math.max(nextKeyframes.length - 1, 0),
-                insertedKeyframeIndex: [...nextKeyframes]
-                    .sort((first, second) => first.frame - second.frame)
-                    .findIndex((keyframe) => keyframe.frame === frame),
-                nextKeyframeCount: nextKeyframes.length,
-                defaultEasing,
-            })
-            : { extraArgs: existing.extraArgs, needsEasingImport: false };
-        return {
-            expression: createInterpolateExpression({
-                callee: b.identifier(nextCalleeName),
-                input: existing.input,
-                extraArgs: normalizedEasing.extraArgs,
-                keyframes: nextKeyframes,
-            }),
-            introduced: {
-                calleeName: schemaCalleeName && schemaCalleeName !== existingCalleeName
-                    ? schemaCalleeName
-                    : null,
-                needsFrameHook: false,
-                needsEasingImport: normalizedEasing.needsEasingImport,
-            },
-        };
-    }
-    const staticNumericExpression = (0, video_config_numeric_expression_1.parseVideoConfigNumericExpression)({
-        node: expression,
-        videoConfigValues,
-    });
-    if (!(0, can_update_sequence_props_1.isStaticValue)(expression) && staticNumericExpression === null) {
-        throw new Error('Cannot add keyframe to computed expression');
-    }
-    const staticValue = (_a = staticNumericExpression === null || staticNumericExpression === void 0 ? void 0 : staticNumericExpression.value) !== null && _a !== void 0 ? _a : (0, can_update_sequence_props_1.extractStaticValue)(expression);
-    const keyframes = [
-        {
-            frame,
-            frameExpression: createFrameExpression(frame),
-            frameNumericExpression: { type: 'literal', value: frame },
-            originalFrame: frame,
-            output: newOutput,
-            value,
-        },
-    ];
-    const callee = getInterpolationCalleeForValues({
-        schema,
-        key,
-        staticValue,
-        newValue: value,
-    });
-    const extraArgs = callee.type === 'Identifier' && callee.name === 'interpolateColors'
-        ? []
-        : [
-            createClampOptionsExpression({
-                defaultOutput: getDefaultKeyframeOutput({ schema, key }),
-            }),
-        ];
-    return {
-        expression: createInterpolateExpression({
-            callee,
-            input: b.identifier('frame'),
-            extraArgs,
-            keyframes,
-        }),
-        introduced: {
-            calleeName: callee.type === 'Identifier'
-                ? callee.name
-                : null,
-            needsFrameHook: true,
-            needsEasingImport: false,
-        },
-    };
-};
-const removeKeyframe = ({ expression, frame, videoConfigValues, valueWhenLastKeyframeDeleted, }) => {
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    if (!existing) {
-        throw new Error('Cannot remove keyframe from non-interpolated expression');
-    }
-    const keyframeIndex = existing.keyframes.findIndex((keyframe) => keyframe.frame === frame);
-    if (keyframeIndex === -1) {
-        throw new Error(`Cannot remove keyframe at frame ${frame}: not found`);
-    }
-    const nextKeyframes = existing.keyframes.filter((_keyframe, index) => index !== keyframeIndex);
-    if (nextKeyframes.length === 0) {
-        return {
-            expression: valueWhenLastKeyframeDeleted === null
-                ? existing.keyframes[keyframeIndex].output
-                : (0, update_nested_prop_1.parseValueExpression)(valueWhenLastKeyframeDeleted),
-            introduced: noIntroducedIdentifiers,
-        };
-    }
-    const normalizedEasing = normalizeEasingAfterRemovingKeyframe({
-        extraArgs: existing.extraArgs,
-        previousSegmentCount: Math.max(existing.keyframes.length - 1, 0),
-        nextSegmentCount: Math.max(nextKeyframes.length - 1, 0),
-        removedKeyframeIndex: keyframeIndex,
-    });
-    return {
-        expression: createInterpolateExpression({
-            callee: existing.callee,
-            input: existing.input,
-            extraArgs: normalizedEasing.extraArgs,
-            keyframes: nextKeyframes,
-        }),
-        introduced: {
-            ...noIntroducedIdentifiers,
-            needsEasingImport: normalizedEasing.needsEasingImport,
-        },
-    };
-};
-const moveKeyframes = ({ expression, moves, videoConfigValues, }) => {
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    if (!existing) {
-        throw new Error('Cannot move keyframe in non-interpolated expression');
-    }
-    const moveMap = new Map();
-    for (const move of moves) {
-        if (move.fromFrame === move.toFrame) {
-            continue;
-        }
-        if (moveMap.has(move.fromFrame)) {
-            throw new Error(`Cannot move keyframe at frame ${move.fromFrame} twice`);
-        }
-        moveMap.set(move.fromFrame, move.toFrame);
-    }
-    if (moveMap.size === 0) {
-        return expression;
-    }
-    const frames = new Set(existing.keyframes.map((keyframe) => keyframe.frame));
-    for (const fromFrame of moveMap.keys()) {
-        if (!frames.has(fromFrame)) {
-            throw new Error(`Cannot move keyframe at frame ${fromFrame}: not found`);
-        }
-    }
-    const movedFromFrames = new Set(moveMap.keys());
-    const movedToFrames = new Set(moveMap.values());
-    const removedKeyframeIndexes = [];
-    const nextKeyframes = existing.keyframes.flatMap((keyframe, index) => {
-        const movedFrame = moveMap.get(keyframe.frame);
-        if (movedFrame !== undefined) {
-            return [{ ...keyframe, frame: movedFrame }];
-        }
-        if (movedToFrames.has(keyframe.frame) &&
-            !movedFromFrames.has(keyframe.frame)) {
-            removedKeyframeIndexes.push(index);
-            return [];
-        }
-        return [keyframe];
-    });
-    const nextFrames = new Set();
-    for (const keyframe of nextKeyframes) {
-        if (nextFrames.has(keyframe.frame)) {
-            throw new Error(`Cannot move keyframe to frame ${keyframe.frame}: frame already exists`);
-        }
-        nextFrames.add(keyframe.frame);
-    }
-    const normalizedEasing = normalizeEasingAfterRemovingKeyframes({
-        extraArgs: existing.extraArgs,
-        previousSegmentCount: Math.max(existing.keyframes.length - 1, 0),
-        nextSegmentCount: Math.max(nextKeyframes.length - 1, 0),
-        removedKeyframeIndexes,
-    });
-    return createInterpolateExpression({
-        callee: existing.callee,
-        input: existing.input,
-        extraArgs: normalizedEasing.extraArgs,
-        keyframes: nextKeyframes,
-    });
-};
-const applyKeyframeOperation = ({ expression, key, operation, schema, videoConfigValues, }) => {
-    if (operation.type === 'add') {
-        return addKeyframe({
-            expression,
-            key,
-            frame: operation.frame,
-            value: operation.value,
-            schema,
-            videoConfigValues,
-        });
-    }
-    if (operation.type === 'settings') {
-        return {
-            expression: updateKeyframeSettings({
-                expression,
-                clamping: operation.clamping,
-                posterize: operation.posterize,
-                output: operation.output,
-                videoConfigValues,
-            }),
-            introduced: noIntroducedIdentifiers,
-        };
-    }
-    if (operation.type === 'easing') {
-        if ((0, studio_shared_1.isSchemaFieldHoldOnly)({ schema, key }) &&
-            operation.easing.type !== 'step1') {
-            throw new Error(`Cannot update easing: "${key}" only supports Easing.step1`);
-        }
-        const updated = updateKeyframeEasing({
-            expression,
-            segmentIndex: operation.segmentIndex,
-            easing: operation.easing,
-            videoConfigValues,
-        });
-        return {
-            expression: updated.expression,
-            introduced: {
-                ...noIntroducedIdentifiers,
-                needsEasingImport: updated.needsEasingImport,
-            },
-        };
-    }
-    if (operation.type === 'move') {
-        return {
-            expression: moveKeyframes({
-                expression,
-                moves: operation.moves,
-                videoConfigValues,
-            }),
-            introduced: noIntroducedIdentifiers,
-        };
-    }
-    return removeKeyframe({
-        expression,
-        frame: operation.frame,
-        videoConfigValues,
-        valueWhenLastKeyframeDeleted: operation.valueWhenLastKeyframeDeleted,
-    });
-};
-const getExpressionFromJsxAttribute = (attr) => {
-    if (!attr.value) {
-        return b.booleanLiteral(true);
-    }
-    if (attr.value.type === 'StringLiteral') {
-        return attr.value;
-    }
-    if (attr.value.type !== 'JSXExpressionContainer') {
-        return null;
-    }
-    const { expression } = attr.value;
-    if (expression.type === 'JSXEmptyExpression') {
-        return null;
-    }
-    return expression;
-};
-const findJsxAttribute = (attributes, name) => {
-    const attrIndex = attributes.findIndex((candidate) => {
-        if (candidate.type === 'JSXSpreadAttribute') {
-            return false;
-        }
-        if (candidate.name.type === 'JSXNamespacedName') {
-            return false;
-        }
-        return candidate.name.name === name;
-    });
-    const foundAttr = attrIndex === -1 ? undefined : attributes[attrIndex];
-    return {
-        attrIndex,
-        attr: foundAttr && foundAttr.type === 'JSXAttribute'
-            ? foundAttr
-            : undefined,
-    };
-};
-const findObjectProperty = (objExpr, propertyName) => {
-    const propIndex = objExpr.properties.findIndex((prop) => prop.type === 'ObjectProperty' &&
-        ((prop.key.type === 'Identifier' && prop.key.name === propertyName) ||
-            (prop.key.type === 'StringLiteral' && prop.key.value === propertyName)));
-    return {
-        propIndex,
-        prop: propIndex === -1
-            ? undefined
-            : objExpr.properties[propIndex],
-    };
-};
-const findFieldInSchema = (schema, key) => {
-    if (key in schema) {
-        return schema[key];
-    }
-    for (const field of Object.values(schema)) {
-        if (field.type !== 'enum') {
-            continue;
-        }
-        for (const variant of Object.values(field.variants)) {
-            const found = findFieldInSchema(variant, key);
-            if (found) {
-                return found;
-            }
-        }
-    }
-    return undefined;
-};
-const getDefaultKeyframeOutput = ({ schema, key, }) => {
-    const field = schema ? findFieldInSchema(schema, key) : undefined;
-    if (((field === null || field === void 0 ? void 0 : field.type) === 'number' || (field === null || field === void 0 ? void 0 : field.type) === 'scale') &&
-        field.defaultKeyframeOutput !== undefined) {
-        return field.defaultKeyframeOutput;
-    }
-    return key === 'style.scale' ? 'perceptual-scale' : null;
-};
-const getInitialValueForMissingProp = ({ schema, key, newValue, }) => {
-    const field = schema ? findFieldInSchema(schema, key) : undefined;
-    if (field && field.type !== 'hidden' && field.default !== undefined) {
-        return field.default;
-    }
-    return newValue;
-};
-const shouldRemovePropAfterKeyframeOperation = ({ expression, key, operation, schema, videoConfigValues, }) => {
-    if (operation.type !== 'remove' || !schema) {
-        return false;
-    }
-    const existing = getInterpolationExpression(expression, videoConfigValues);
-    if (!existing || existing.keyframes.length !== 1) {
-        return false;
-    }
-    const field = findFieldInSchema(schema, key);
-    if (!field || field.type === 'hidden' || field.default === undefined) {
-        return false;
-    }
-    const valueAfterRemoval = operation.valueWhenLastKeyframeDeleted === null
-        ? existing.keyframes[0].value
-        : operation.valueWhenLastKeyframeDeleted;
-    return JSON.stringify(valueAfterRemoval) === JSON.stringify(field.default);
-};
-const getObjectExpression = (attr) => {
-    if (!attr.value || attr.value.type !== 'JSXExpressionContainer') {
-        return null;
-    }
-    if (attr.value.expression.type !== 'ObjectExpression') {
-        return null;
-    }
-    return attr.value.expression;
-};
-const createJsxExpressionAttribute = (key, expression) => {
-    return b.jsxAttribute(b.jsxIdentifier(key), b.jsxExpressionContainer(expression));
-};
-const createObjectProperty = (key, value) => b.objectProperty(b.identifier(key), value);
-const createObjectExpressionAttribute = ({ parentKey, childKey, expression, }) => {
-    return createJsxExpressionAttribute(parentKey, b.objectExpression([
-        createObjectProperty(childKey, expression),
-    ]));
-};
-const createMissingPropExpression = (missingPropInitialValue) => {
-    return (0, update_nested_prop_1.parseValueExpression)(missingPropInitialValue.value);
-};
-const getSequenceWritableProp = ({ attributes, key, missingPropInitialValue, }) => {
-    const dotIndex = key.indexOf('.');
-    if (dotIndex === -1) {
-        const { attrIndex, attr: topLevelAttr } = findJsxAttribute(attributes, key);
-        if (!topLevelAttr) {
-            if (missingPropInitialValue) {
-                return {
-                    expression: createMissingPropExpression(missingPropInitialValue),
-                    setExpression: (nextExpression) => {
-                        attributes.push(createJsxExpressionAttribute(key, nextExpression));
-                    },
-                    remove: () => undefined,
-                };
-            }
-            throw new Error(`Cannot update keyframes: "${key}" is not set`);
-        }
-        const expression = getExpressionFromJsxAttribute(topLevelAttr);
-        if (!expression) {
-            throw new Error(`Cannot update keyframes: "${key}" is computed`);
-        }
-        return {
-            expression,
-            setExpression: (nextExpression) => {
-                topLevelAttr.value = b.jsxExpressionContainer(nextExpression);
-            },
-            remove: () => {
-                attributes.splice(attrIndex, 1);
-            },
-        };
-    }
-    const parentKey = key.slice(0, dotIndex);
-    const childKey = key.slice(dotIndex + 1);
-    const { attrIndex: parentAttrIndex, attr: parentAttr } = findJsxAttribute(attributes, parentKey);
-    if (!parentAttr) {
-        if (missingPropInitialValue) {
-            return {
-                expression: createMissingPropExpression(missingPropInitialValue),
-                setExpression: (nextExpression) => {
-                    attributes.push(createObjectExpressionAttribute({
-                        parentKey,
-                        childKey,
-                        expression: nextExpression,
-                    }));
-                },
-                remove: () => undefined,
-            };
-        }
-        throw new Error(`Cannot update keyframes: "${parentKey}" is not set`);
-    }
-    const objExpr = getObjectExpression(parentAttr);
-    if (!objExpr) {
-        throw new Error(`Cannot update keyframes: "${parentKey}" is computed`);
-    }
-    const { propIndex, prop } = findObjectProperty(objExpr, childKey);
-    if (!prop) {
-        if (missingPropInitialValue) {
-            return {
-                expression: createMissingPropExpression(missingPropInitialValue),
-                setExpression: (nextExpression) => {
-                    objExpr.properties.push(createObjectProperty(childKey, nextExpression));
-                },
-                remove: () => undefined,
-            };
-        }
-        throw new Error(`Cannot update keyframes: "${key}" is not set`);
-    }
-    return {
-        expression: prop.value,
-        setExpression: (nextExpression) => {
-            prop.value = nextExpression;
-        },
-        remove: () => {
-            objExpr.properties.splice(propIndex, 1);
-            if (objExpr.properties.length === 0) {
-                attributes.splice(parentAttrIndex, 1);
-            }
-        },
-    };
-};
-const getEffectWritableProp = ({ objExpr, key, missingPropInitialValue, }) => {
-    const { propIndex, prop } = findObjectProperty(objExpr, key);
-    if (!prop) {
-        if (missingPropInitialValue) {
-            return {
-                expression: createMissingPropExpression(missingPropInitialValue),
-                setExpression: (nextExpression) => {
-                    objExpr.properties.push(createObjectProperty(key, nextExpression));
-                },
-                remove: () => undefined,
-            };
-        }
-        throw new Error(`Cannot update keyframes: "${key}" is not set`);
-    }
-    return {
-        expression: prop.value,
-        setExpression: (nextExpression) => {
-            prop.value = nextExpression;
-        },
-        remove: () => {
-            objExpr.properties.splice(propIndex, 1);
-        },
-    };
-};
-const getEffectPropsObjectExpression = (call) => {
-    if (call.arguments.length === 0) {
-        const objExpr = b.objectExpression([]);
-        call.arguments.push(objExpr);
-        return objExpr;
-    }
-    if (call.arguments[0].type !== 'ObjectExpression') {
-        throw new Error('Cannot update effect keyframe: computed');
-    }
-    return call.arguments[0];
-};
-const updateSequenceKeyframesAst = ({ input, nodePath, updates, schema, videoConfigValues, }) => {
-    var _a;
-    var _b;
-    const ast = (0, parse_ast_1.parseAst)(input);
-    const videoConfigIdentifierValues = (0, video_config_values_1.getVideoConfigIdentifierValues)({
-        ast,
-        videoConfigValues,
-    });
-    const jsxPath = (0, get_ast_node_path_1.getAstNodePath)(ast, nodePath);
-    const node = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, nodePath);
-    if (!node || !jsxPath) {
-        throw new Error('Could not find a JSX element at the specified location to update keyframes');
-    }
-    if (!node.attributes) {
-        node.attributes = [];
-    }
-    const requiredImports = new Set();
-    let needsFrameHook = false;
-    const oldValueStrings = [];
-    const newValueStrings = [];
-    for (const update of updates) {
-        const prop = getSequenceWritableProp({
-            attributes: node.attributes,
-            key: update.key,
-            missingPropInitialValue: update.operation.type === 'add'
-                ? {
-                    value: getInitialValueForMissingProp({
-                        schema: schema !== null && schema !== void 0 ? schema : null,
-                        key: update.key,
-                        newValue: update.operation.value,
-                    }),
-                }
-                : null,
-        });
-        oldValueStrings.push(recast.print(prop.expression).code);
-        const { expression: nextExpression, introduced } = applyKeyframeOperation({
-            expression: prop.expression,
-            key: update.key,
-            operation: update.operation,
-            schema: schema !== null && schema !== void 0 ? schema : null,
-            videoConfigValues: videoConfigIdentifierValues,
-        });
-        newValueStrings.push(recast.print(nextExpression).code);
-        if (shouldRemovePropAfterKeyframeOperation({
-            expression: prop.expression,
-            key: update.key,
-            operation: update.operation,
-            schema: schema !== null && schema !== void 0 ? schema : null,
-            videoConfigValues: videoConfigIdentifierValues,
-        })) {
-            prop.remove();
-        }
-        else {
-            prop.setExpression(nextExpression);
-        }
-        if (introduced.calleeName) {
-            requiredImports.add(introduced.calleeName);
-        }
-        if (introduced.needsFrameHook) {
-            requiredImports.add('useCurrentFrame');
-            needsFrameHook = true;
-        }
-        if (introduced.needsEasingImport) {
-            requiredImports.add('Easing');
-        }
-    }
-    if (needsFrameHook) {
-        const fnPath = (0, ensure_imports_and_frame_hook_1.findEnclosingFunctionPath)(jsxPath);
-        if (fnPath) {
-            (0, ensure_imports_and_frame_hook_1.ensureUseCurrentFrameHook)(fnPath);
-        }
-    }
-    (0, ensure_imports_and_frame_hook_1.ensureRemotionImports)(ast, requiredImports);
-    const updatedNodePath = (0, can_update_sequence_props_1.findNodePathForJsxElement)(ast, node);
-    if (!updatedNodePath) {
-        throw new Error('Could not find updated JSX element location after updating keyframes');
-    }
-    return {
-        serialized: (0, parse_ast_1.serializeAst)(ast),
-        oldValueStrings,
-        newValueStrings,
-        logLine: (_b = (_a = node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _b !== void 0 ? _b : 1,
-        updatedNodePath,
-    };
-};
-exports.updateSequenceKeyframesAst = updateSequenceKeyframesAst;
-const updateSequenceKeyframes = async ({ input, nodePath, updates, schema, prettierConfigOverride, videoConfigValues, }) => {
-    const { serialized, oldValueStrings, newValueStrings, logLine, updatedNodePath, } = (0, exports.updateSequenceKeyframesAst)({
-        input,
-        nodePath,
-        updates,
-        schema,
-        videoConfigValues,
-    });
-    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
-        input: serialized,
-        prettierConfigOverride,
-    });
-    const outputWithoutInsertedBlankLines = removeBlankLinesFromObjectsWithProperties({
-        input: output,
-        propertyNames: updates.map((update) => getObjectPropertyNameFromUpdateKey(update.key)),
-    });
-    return {
-        output: outputWithoutInsertedBlankLines,
-        formatted,
-        oldValueStrings,
-        newValueStrings,
-        logLine,
-        updatedNodePath,
-    };
-};
+const studio_codemods_2 = require("@remotion/studio-codemods");
+Object.defineProperty(exports, "updateEffectKeyframesAst", { enumerable: true, get: function () { return studio_codemods_2.updateEffectKeyframesAst; } });
+Object.defineProperty(exports, "updateSequenceKeyframesAst", { enumerable: true, get: function () { return studio_codemods_2.updateSequenceKeyframesAst; } });
+const formatKeyframesFile = ({ contents, prettierConfigOverride, }) => (0, format_file_content_1.formatFileContent)({
+    input: contents,
+    prettierConfigOverride,
+});
+const updateSequenceKeyframes = (input) => (0, studio_codemods_1.updateSequenceKeyframes)({ ...input, formatFile: formatKeyframesFile });
 exports.updateSequenceKeyframes = updateSequenceKeyframes;
-const updateEffectKeyframesAst = ({ input, sequenceNodePath, effectIndex, updates, schema, videoConfigValues, }) => {
-    var _a, _b;
-    var _c, _d, _e;
-    const ast = (0, parse_ast_1.parseAst)(input);
-    const videoConfigIdentifierValues = (0, video_config_values_1.getVideoConfigIdentifierValues)({
-        ast,
-        videoConfigValues,
-    });
-    const jsxPath = (0, get_ast_node_path_1.getAstNodePath)(ast, sequenceNodePath);
-    const jsx = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, sequenceNodePath);
-    if (!jsx || !jsxPath) {
-        throw new Error('Could not find a JSX element at the specified location to update effect keyframes');
-    }
-    const attr = (0, update_effect_props_1.findEffectsAttr)((_c = jsx.attributes) !== null && _c !== void 0 ? _c : []);
-    if (!attr) {
-        throw new Error('Could not find effects on the target JSX element');
-    }
-    const found = (0, update_effect_props_1.findEffectCallExpression)({ attr, effectIndex });
-    if (found.kind === 'error') {
-        throw new Error(`Cannot update effect keyframe: ${found.reason}`);
-    }
-    const { call, callee: effectCallee } = found;
-    const objExpr = getEffectPropsObjectExpression(call);
-    const oldValueStrings = [];
-    const newValueStrings = [];
-    const requiredImports = new Set();
-    let needsFrameHook = false;
-    for (const update of updates) {
-        const prop = getEffectWritableProp({
-            objExpr,
-            key: update.key,
-            missingPropInitialValue: update.operation.type === 'add'
-                ? {
-                    value: getInitialValueForMissingProp({
-                        schema: schema !== null && schema !== void 0 ? schema : null,
-                        key: update.key,
-                        newValue: update.operation.value,
-                    }),
-                }
-                : null,
-        });
-        oldValueStrings.push(recast.print(prop.expression).code);
-        const { expression: nextExpression, introduced } = applyKeyframeOperation({
-            expression: prop.expression,
-            key: update.key,
-            operation: update.operation,
-            schema: schema !== null && schema !== void 0 ? schema : null,
-            videoConfigValues: videoConfigIdentifierValues,
-        });
-        newValueStrings.push(recast.print(nextExpression).code);
-        if (shouldRemovePropAfterKeyframeOperation({
-            expression: prop.expression,
-            key: update.key,
-            operation: update.operation,
-            schema: schema !== null && schema !== void 0 ? schema : null,
-            videoConfigValues: videoConfigIdentifierValues,
-        })) {
-            prop.remove();
-        }
-        else {
-            prop.setExpression(nextExpression);
-        }
-        if (introduced.calleeName) {
-            requiredImports.add(introduced.calleeName);
-        }
-        if (introduced.needsFrameHook) {
-            requiredImports.add('useCurrentFrame');
-            needsFrameHook = true;
-        }
-        if (introduced.needsEasingImport) {
-            requiredImports.add('Easing');
-        }
-    }
-    if (needsFrameHook) {
-        const fnPath = (0, ensure_imports_and_frame_hook_1.findEnclosingFunctionPath)(jsxPath);
-        if (fnPath) {
-            (0, ensure_imports_and_frame_hook_1.ensureUseCurrentFrameHook)(fnPath);
-        }
-    }
-    (0, ensure_imports_and_frame_hook_1.ensureRemotionImports)(ast, requiredImports);
-    const updatedSequenceNodePath = (0, can_update_sequence_props_1.findNodePathForJsxElement)(ast, jsx);
-    if (!updatedSequenceNodePath) {
-        throw new Error('Could not find updated JSX element location after updating effect keyframes');
-    }
-    return {
-        serialized: (0, parse_ast_1.serializeAst)(ast),
-        oldValueStrings,
-        newValueStrings,
-        logLine: (_e = (_d = (_a = call.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : (_b = jsx.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _e !== void 0 ? _e : 1,
-        effectCallee,
-        updatedSequenceNodePath,
-    };
-};
-exports.updateEffectKeyframesAst = updateEffectKeyframesAst;
-const updateEffectKeyframes = async ({ input, sequenceNodePath, effectIndex, updates, schema, prettierConfigOverride, videoConfigValues, }) => {
-    const { serialized, oldValueStrings, newValueStrings, logLine, effectCallee, updatedSequenceNodePath, } = (0, exports.updateEffectKeyframesAst)({
-        input,
-        sequenceNodePath,
-        effectIndex,
-        updates,
-        schema,
-        videoConfigValues,
-    });
-    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
-        input: serialized,
-        prettierConfigOverride,
-    });
-    const outputWithoutInsertedBlankLines = removeBlankLinesFromObjectsWithProperties({
-        input: output,
-        propertyNames: updates.map((update) => update.key),
-    });
-    return {
-        output: outputWithoutInsertedBlankLines,
-        formatted,
-        oldValueStrings,
-        newValueStrings,
-        logLine,
-        effectCallee,
-        updatedSequenceNodePath,
-    };
-};
+const updateEffectKeyframes = (input) => (0, studio_codemods_1.updateEffectKeyframes)({ ...input, formatFile: formatKeyframesFile });
 exports.updateEffectKeyframes = updateEffectKeyframes;