@remotion/studio-server 4.0.484 → 4.0.485

package/dist/codemods/recast-mods.js

@@ -96,6 +96,7 @@ const mapReturnStatement = (statement, transformation, changesMade, parentFolder
         return statement;
     }
     if (transformation.type === 'new-composition' &&
+        transformation.folderName === null &&
         (statement.argument.type === 'JSXElement' ||
             statement.argument.type === 'JSXFragment')) {
         return {
@@ -191,6 +192,30 @@ const addNewCompositionToRootJsx = (root, transformation, changesMade) => {
     }
     return wrapInJsxFragment([root, newCompositionElement(transformation)]);
 };
+const addNewCompositionToFolder = (folderElement, transformation, changesMade) => {
+    var _a;
+    if (changesMade.length > 0) {
+        return folderElement;
+    }
+    changesMade.push({
+        description: 'Added new composition',
+    });
+    return {
+        ...folderElement,
+        openingElement: {
+            ...folderElement.openingElement,
+            selfClosing: false,
+        },
+        closingElement: (_a = folderElement.closingElement) !== null && _a !== void 0 ? _a : {
+            type: 'JSXClosingElement',
+            name: folderElement.openingElement.name,
+        },
+        children: [
+            ...folderElement.children,
+            newCompositionElement(transformation),
+        ],
+    };
+};
 // When a <Composition> JSX element appears in a position where it cannot
 // simply be removed from a parent's children list (e.g. as the sole return
 // value of a wrapper component or as the concise body of an arrow function),
@@ -208,6 +233,9 @@ const transformLoneJsxElement = (expression, transformation, changesMade, parent
                 folderName === transformation.folderName &&
                 parentFolderName === transformation.parentName) ||
                 (transformation.type === 'rename-folder' &&
+                    folderName === transformation.folderName &&
+                    parentFolderName === transformation.parentName) ||
+                (transformation.type === 'new-composition' &&
                     folderName === transformation.folderName &&
                     parentFolderName === transformation.parentName));
         if (!isFolderMatch) {
@@ -224,6 +252,9 @@ const transformLoneJsxElement = (expression, transformation, changesMade, parent
             folderName === transformation.folderName &&
             parentFolderName === transformation.parentName) ||
         (transformation.type === 'rename-folder' &&
+            folderName === transformation.folderName &&
+            parentFolderName === transformation.parentName) ||
+        (transformation.type === 'new-composition' &&
             folderName === transformation.folderName &&
             parentFolderName === transformation.parentName);
     if (!isMatch) {
@@ -318,6 +349,11 @@ const mapJsxChild = (c, transformation, changesMade, parentFolderName) => {
         });
         return c.children;
     }
+    if (transformation.type === 'new-composition' &&
+        folderName === transformation.folderName &&
+        parentFolderName === transformation.parentName) {
+        return [addNewCompositionToFolder(c, transformation, changesMade)];
+    }
     const childParentFolderName = folderName
         ? getChildFolderParentName({ folderName, parentFolderName })
         : parentFolderName;
@@ -330,6 +366,7 @@ const mapRecognizedType = (expression, transformation, changesMade, parentFolder
     if (expression.type === 'ArrowFunctionExpression' ||
         expression.type === 'FunctionExpression') {
         if (transformation.type === 'new-composition' &&
+            transformation.folderName === null &&
             (expression.body.type === 'JSXElement' ||
                 expression.body.type === 'JSXFragment')) {
             return {

package/dist/codemods/split-jsx-sequence.d.ts

@@ -0,0 +1,14 @@
+import type { SequenceNodePath } from 'remotion';
+export declare const getSplitUnsupportedSequenceTagReason: (tagName: string) => string | null;
+export declare const getIsSplittableSequenceTag: (tagName: string) => boolean;
+export declare const splitJsxSequence: ({ input, nodePath, splitFrame, prettierConfigOverride, }: {
+    input: string;
+    nodePath: SequenceNodePath;
+    splitFrame: number;
+    prettierConfigOverride?: Record<string, unknown> | null | undefined;
+}) => Promise<{
+    output: string;
+    formatted: boolean;
+    nodeLabel: string;
+    logLine: number;
+}>;

package/dist/codemods/split-jsx-sequence.js

@@ -0,0 +1,345 @@
+"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.splitJsxSequence = exports.getIsSplittableSequenceTag = exports.getSplitUnsupportedSequenceTagReason = void 0;
+const types_1 = require("@babel/types");
+const recast = __importStar(require("recast"));
+const delete_jsx_node_1 = require("./delete-jsx-node");
+const format_file_content_1 = require("./format-file-content");
+const parse_ast_1 = require("./parse-ast");
+const { builders: b, namedTypes } = recast.types;
+const jsxId = (name) => ({ type: 'JSXIdentifier', name });
+const numericAttribute = (name, value) => ({
+    type: 'JSXAttribute',
+    name: jsxId(name),
+    value: {
+        type: 'JSXExpressionContainer',
+        expression: value === Infinity ? b.identifier('Infinity') : b.numericLiteral(value),
+    },
+});
+const getAttributeName = (attribute) => {
+    if (attribute.type !== 'JSXAttribute' ||
+        attribute.name.type !== 'JSXIdentifier') {
+        return null;
+    }
+    return attribute.name.name;
+};
+const getStaticNumber = (attribute) => {
+    if (attribute.type !== 'JSXAttribute') {
+        return null;
+    }
+    if (!attribute.value) {
+        return null;
+    }
+    if (attribute.value.type === 'StringLiteral') {
+        const parsed = Number(attribute.value.value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    if (attribute.value.type !== 'JSXExpressionContainer') {
+        return null;
+    }
+    const { expression } = attribute.value;
+    if (expression.type === 'NumericLiteral') {
+        return expression.value;
+    }
+    if (expression.type === 'Identifier' && expression.name === 'Infinity') {
+        return Infinity;
+    }
+    return null;
+};
+const readSequenceTiming = (element) => {
+    let from = 0;
+    let durationInFrames = Infinity;
+    let trimBefore = 0;
+    let hasFrom = false;
+    let hasDurationInFrames = false;
+    let hasTrimBefore = false;
+    for (const attribute of element.openingElement.attributes) {
+        const name = getAttributeName(attribute);
+        if (!name) {
+            continue;
+        }
+        if (name !== 'from' &&
+            name !== 'durationInFrames' &&
+            name !== 'trimBefore') {
+            continue;
+        }
+        const value = getStaticNumber(attribute);
+        if (value === null) {
+            throw new Error(`Cannot split sequence with dynamic ${name}`);
+        }
+        if (name === 'from') {
+            from = value;
+            hasFrom = true;
+        }
+        if (name === 'durationInFrames') {
+            durationInFrames = value;
+            hasDurationInFrames = true;
+        }
+        if (name === 'trimBefore') {
+            trimBefore = value;
+            hasTrimBefore = true;
+        }
+    }
+    return {
+        from,
+        durationInFrames,
+        trimBefore,
+        hasFrom,
+        hasDurationInFrames,
+        hasTrimBefore,
+    };
+};
+const setNumericAttribute = ({ element, name, value, omitIfMissing, }) => {
+    const { openingElement: { attributes }, } = element;
+    const index = attributes.findIndex((attribute) => getAttributeName(attribute) === name);
+    if (value === null || (index === -1 && omitIfMissing)) {
+        if (index !== -1) {
+            attributes.splice(index, 1);
+        }
+        return;
+    }
+    const next = numericAttribute(name, value);
+    if (index === -1) {
+        attributes.push(next);
+    }
+    else {
+        attributes[index] = next;
+    }
+};
+const timingAttributeOrder = ['from', 'durationInFrames', 'trimBefore'];
+const orderTimingAttributes = (element) => {
+    const { openingElement: { attributes }, } = element;
+    const timingAttributes = new Map();
+    const otherAttributes = [];
+    let firstTimingIndex = null;
+    for (let i = 0; i < attributes.length; i++) {
+        const attribute = attributes[i];
+        const name = getAttributeName(attribute);
+        if (name && timingAttributeOrder.includes(name)) {
+            timingAttributes.set(name, attribute);
+            firstTimingIndex = firstTimingIndex === null ? i : firstTimingIndex;
+        }
+        else {
+            otherAttributes.push(attribute);
+        }
+    }
+    if (firstTimingIndex === null) {
+        return;
+    }
+    const orderedTimingAttributes = timingAttributeOrder.flatMap((name) => {
+        const attribute = timingAttributes.get(name);
+        return attribute ? [attribute] : [];
+    });
+    const insertionIndex = Math.min(firstTimingIndex, otherAttributes.length);
+    attributes.splice(0, attributes.length, ...otherAttributes.slice(0, insertionIndex), ...orderedTimingAttributes, ...otherAttributes.slice(insertionIndex));
+};
+const splittableSequenceTags = new Set([
+    'AnimatedImage',
+    'Arrow',
+    'Audio',
+    'Callout',
+    'CanvasImage',
+    'Circle',
+    'Ellipse',
+    'Gif',
+    'Heart',
+    'Html5Audio',
+    'Html5Video',
+    'HtmlInCanvas',
+    'Img',
+    'OffthreadVideo',
+    'Pie',
+    'Polygon',
+    'Rect',
+    'RemotionRiveCanvas',
+    'Sequence',
+    'Solid',
+    'Spark',
+    'Star',
+    'Starburst',
+    'Triangle',
+    'Video',
+]);
+const unsupportedSequenceTags = new Set([
+    'Series.Sequence',
+    'TransitionSeries.Overlay',
+    'TransitionSeries.Sequence',
+]);
+const jsxMemberNameToString = (name) => {
+    if (name.type === 'JSXIdentifier') {
+        return name.name;
+    }
+    return `${jsxMemberNameToString(name.object)}.${name.property.name}`;
+};
+const jsxNameToString = (name) => {
+    if (name.type === 'JSXNamespacedName') {
+        return `${name.namespace.name}:${name.name.name}`;
+    }
+    return jsxMemberNameToString(name);
+};
+const getSplitUnsupportedSequenceTagReason = (tagName) => {
+    if (tagName === 'Series.Sequence' ||
+        tagName === 'TransitionSeries.Sequence' ||
+        tagName === 'TransitionSeries.Overlay') {
+        return `<${tagName}> cannot be split from source`;
+    }
+    return null;
+};
+exports.getSplitUnsupportedSequenceTagReason = getSplitUnsupportedSequenceTagReason;
+const getIsSplittableSequenceTag = (tagName) => {
+    if (unsupportedSequenceTags.has(tagName)) {
+        return false;
+    }
+    if (tagName.startsWith('Interactive.')) {
+        return true;
+    }
+    return splittableSequenceTags.has(tagName);
+};
+exports.getIsSplittableSequenceTag = getIsSplittableSequenceTag;
+const getSplittableSequenceTagName = (element) => {
+    return jsxNameToString(element.openingElement.name);
+};
+const makeFragment = (first, second) => ({
+    type: 'JSXFragment',
+    openingFragment: { type: 'JSXOpeningFragment' },
+    closingFragment: { type: 'JSXClosingFragment' },
+    children: [first, second],
+});
+const insertAfter = (parentNode, node, clone) => {
+    if (namedTypes.JSXElement.check(parentNode) ||
+        namedTypes.JSXFragment.check(parentNode)) {
+        const idx = parentNode.children.indexOf(node);
+        if (idx !== -1) {
+            parentNode.children.splice(idx + 1, 0, clone);
+            return true;
+        }
+    }
+    if (namedTypes.ReturnStatement.check(parentNode)) {
+        const parent = parentNode;
+        if (parent.argument === node) {
+            parent.argument = makeFragment(node, clone);
+            return true;
+        }
+    }
+    if (namedTypes.ArrowFunctionExpression.check(parentNode)) {
+        const parent = parentNode;
+        if (parent.body === node) {
+            parent.body = makeFragment(node, clone);
+            return true;
+        }
+    }
+    return false;
+};
+const splitJsxSequence = async ({ input, nodePath, splitFrame, prettierConfigOverride, }) => {
+    var _a, _b;
+    var _c, _d;
+    if (!Number.isInteger(splitFrame)) {
+        throw new Error('Split frame must be an integer');
+    }
+    const ast = (0, parse_ast_1.parseAst)(input);
+    const jsxPath = (0, delete_jsx_node_1.findJsxElementPathForDeletion)(ast, nodePath);
+    if (!jsxPath) {
+        throw new Error('Could not find a JSX sequence at the specified location to split');
+    }
+    const jsxElement = jsxPath.node;
+    const tagName = getSplittableSequenceTagName(jsxElement);
+    const unsupportedReason = (0, exports.getSplitUnsupportedSequenceTagReason)(tagName);
+    if (unsupportedReason) {
+        throw new Error(unsupportedReason);
+    }
+    if (!(0, exports.getIsSplittableSequenceTag)(tagName)) {
+        throw new Error(`<${tagName}> does not support sequence timing props and cannot be split`);
+    }
+    const timing = readSequenceTiming(jsxElement);
+    const finiteEnd = timing.durationInFrames === Infinity
+        ? Infinity
+        : timing.from + timing.durationInFrames;
+    if (splitFrame <= timing.from) {
+        throw new Error('Cannot split at or before the sequence start');
+    }
+    if (splitFrame >= finiteEnd) {
+        throw new Error('Cannot split at or after the sequence end');
+    }
+    const right = (0, types_1.cloneNode)(jsxElement, true);
+    const leftDuration = splitFrame - timing.from;
+    const rightDuration = timing.durationInFrames === Infinity ? Infinity : finiteEnd - splitFrame;
+    const rightTrimBefore = timing.trimBefore + leftDuration;
+    setNumericAttribute({
+        element: jsxElement,
+        name: 'durationInFrames',
+        value: leftDuration,
+        omitIfMissing: false,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'from',
+        value: splitFrame,
+        omitIfMissing: false,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'durationInFrames',
+        value: rightDuration === Infinity ? null : rightDuration,
+        omitIfMissing: !timing.hasDurationInFrames,
+    });
+    setNumericAttribute({
+        element: right,
+        name: 'trimBefore',
+        value: rightTrimBefore === 0 ? null : rightTrimBefore,
+        omitIfMissing: !timing.hasTrimBefore && rightTrimBefore === 0,
+    });
+    orderTimingAttributes(jsxElement);
+    orderTimingAttributes(right);
+    const { parentPath } = jsxPath;
+    if (!parentPath) {
+        throw new Error('Cannot split JSX sequence with no parent');
+    }
+    if (!insertAfter(parentPath.node, jsxElement, right)) {
+        jsxPath.replace(makeFragment(jsxElement, right));
+    }
+    const finalFile = (0, parse_ast_1.serializeAst)(ast);
+    const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
+        input: finalFile,
+        prettierConfigOverride,
+    });
+    return {
+        output,
+        formatted,
+        nodeLabel: (0, delete_jsx_node_1.getJsxElementTagLabel)(jsxElement),
+        logLine: (_d = (_c = (_a = jsxElement.openingElement.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _c !== void 0 ? _c : (_b = jsxElement.loc) === null || _b === void 0 ? void 0 : _b.start.line) !== null && _d !== void 0 ? _d : 1,
+    };
+};
+exports.splitJsxSequence = splitJsxSequence;

package/dist/codemods/update-sequence-props/update-sequence-props.d.ts

@@ -1,4 +1,4 @@
-import type { SequenceNodePath, InteractivitySchema } from 'remotion';
+import type { InteractivitySchema, SequenceNodePath } from 'remotion';
 export type SequencePropUpdate = {
     key: string;
     value: unknown;

package/dist/codemods/update-sequence-props/update-sequence-props.js

@@ -85,9 +85,59 @@ const snapshotTopLevelAttrs = (node) => {
     }
     return result;
 };
-const updateSequencePropsNode = ({ node, updates, schema, }) => {
+const escapeJsxText = (value) => {
+    return value
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/{/g, '&#123;')
+        .replace(/}/g, '&#125;');
+};
+const findChildrenAttribute = (node) => {
+    var _a;
+    return (_a = node.attributes) === null || _a === void 0 ? void 0 : _a.find((attr) => {
+        return (attr.type === 'JSXAttribute' &&
+            attr.name.type === 'JSXIdentifier' &&
+            attr.name.name === 'children');
+    });
+};
+const updateJsxTextContent = ({ jsxElement, value, }) => {
+    const nextValue = String(value !== null && value !== void 0 ? value : '');
+    const staticChildrenAttribute = (0, can_update_sequence_props_1.getStaticJsxChildrenAttribute)(jsxElement.openingElement);
+    if (staticChildrenAttribute) {
+        const childrenAttribute = findChildrenAttribute(jsxElement.openingElement);
+        if (!childrenAttribute) {
+            throw new Error('Expected static children attribute to exist');
+        }
+        childrenAttribute.value = b.stringLiteral(nextValue);
+        return staticChildrenAttribute.value;
+    }
+    if ((0, can_update_sequence_props_1.hasJsxChildrenAttribute)(jsxElement.openingElement)) {
+        throw new Error('Cannot update text content because the children attribute is not static text');
+    }
+    const staticTextContent = (0, can_update_sequence_props_1.getStaticJsxTextContent)(jsxElement);
+    if (!staticTextContent) {
+        throw new Error('Cannot update text content because JSX children are not static text');
+    }
+    const canRepresentAsJsxText = staticTextContent.kind === 'jsx-text' &&
+        !nextValue.includes('\n') &&
+        nextValue.trim() === nextValue;
+    if (canRepresentAsJsxText) {
+        jsxElement.children = [
+            b.jsxText(escapeJsxText(nextValue)),
+        ];
+    }
+    else {
+        jsxElement.children = [
+            b.jsxExpressionContainer(b.stringLiteral(nextValue)),
+        ];
+    }
+    return staticTextContent.value;
+};
+const updateSequencePropsNode = ({ jsxElement, updates, schema, }) => {
     var _a, _b, _c;
     var _d, _e;
+    const node = jsxElement.openingElement;
     const logLine = (_d = (_a = node.loc) === null || _a === void 0 ? void 0 : _a.start.line) !== null && _d !== void 0 ? _d : 1;
     const oldValueStrings = [];
     const initialAttrs = snapshotTopLevelAttrs(node);
@@ -97,6 +147,11 @@ const updateSequencePropsNode = ({ node, updates, schema, }) => {
     }));
     for (const { key, value, defaultValue } of updates) {
         let oldValueString = '';
+        if (key === 'children') {
+            oldValueString = updateJsxTextContent({ jsxElement, value });
+            oldValueStrings.push(oldValueString);
+            continue;
+        }
         const isDefault = defaultValue !== null &&
             JSON.stringify(value) === JSON.stringify(defaultValue);
         const dotIndex = key.indexOf('.');
@@ -197,12 +252,12 @@ const updateSequencePropsNode = ({ node, updates, schema, }) => {
 };
 const updateSequencePropsAst = ({ input, nodePath, updates, schema, }) => {
     const ast = (0, parse_ast_1.parseAst)(input);
-    const node = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, nodePath);
-    if (!node) {
+    const jsxElement = (0, can_update_sequence_props_1.findJsxElementNodeAtNodePath)(ast, nodePath);
+    if (!jsxElement) {
         throw new Error('Could not find a JSX element at the specified line to update');
     }
     const { oldValueStrings, logLine, removedProps } = updateSequencePropsNode({
-        node,
+        jsxElement,
         updates,
         schema,
     });
@@ -217,11 +272,11 @@ exports.updateSequencePropsAst = updateSequencePropsAst;
 const updateMultipleSequenceProps = async ({ input, changes, prettierConfigOverride, }) => {
     const ast = (0, parse_ast_1.parseAst)(input);
     const results = changes.map(({ nodePath, updates, schema }) => {
-        const node = (0, can_update_sequence_props_1.findJsxElementAtNodePath)(ast, nodePath);
-        if (!node) {
+        const jsxElement = (0, can_update_sequence_props_1.findJsxElementNodeAtNodePath)(ast, nodePath);
+        if (!jsxElement) {
             throw new Error('Could not find a JSX element at the specified line to update');
         }
-        return updateSequencePropsNode({ node, updates, schema });
+        return updateSequencePropsNode({ jsxElement, updates, schema });
     });
     const { output, formatted } = await (0, format_file_content_1.formatFileContent)({
         input: (0, parse_ast_1.serializeAst)(ast),

package/dist/preview-server/api-routes.js

@@ -35,6 +35,7 @@ const reorder_sequence_1 = require("./routes/reorder-sequence");
 const restart_studio_1 = require("./routes/restart-studio");
 const save_effect_props_1 = require("./routes/save-effect-props");
 const save_sequence_props_1 = require("./routes/save-sequence-props");
+const split_jsx_sequence_1 = require("./routes/split-jsx-sequence");
 const subscribe_to_default_props_1 = require("./routes/subscribe-to-default-props");
 const subscribe_to_file_existence_1 = require("./routes/subscribe-to-file-existence");
 const subscribe_to_sequence_props_1 = require("./routes/subscribe-to-sequence-props");
@@ -82,6 +83,7 @@ exports.allApiRoutes = {
     '/api/paste-effects': paste_effects_1.pasteEffectsHandler,
     '/api/delete-jsx-node': delete_jsx_node_1.deleteJsxNodeHandler,
     '/api/duplicate-jsx-node': duplicate_jsx_node_1.duplicateJsxNodeHandler,
+    '/api/split-jsx-sequence': split_jsx_sequence_1.splitJsxSequenceHandler,
     '/api/update-available': update_available_1.handleUpdate,
     '/api/project-info': project_info_1.projectInfoHandler,
     '/api/delete-static-file': delete_static_file_1.deleteStaticFileHandler,

package/dist/preview-server/routes/add-effect-keyframe.js

@@ -13,8 +13,8 @@ const watch_ignore_next_change_1 = require("../watch-ignore-next-change");
 const can_update_effect_props_1 = require("./can-update-effect-props");
 const can_update_sequence_props_1 = require("./can-update-sequence-props");
 const log_effect_update_1 = require("./log-updates/log-effect-update");
-const save_props_mutex_1 = require("./save-props-mutex");
-const addEffectKeyframeHandler = ({ input: { fileName, sequenceNodePath, effectIndex, key, frame, value, schema, clientId, }, remotionRoot, logLevel, }) => (0, save_props_mutex_1.withSavePropsLock)(async () => {
+const source_file_write_queue_1 = require("./source-file-write-queue");
+const addEffectKeyframeHandler = ({ input: { fileName, sequenceNodePath, effectIndex, key, frame, value, schema, clientId, }, remotionRoot, logLevel, }) => (0, source_file_write_queue_1.withSourceFileWriteQueue)(async () => {
     renderer_1.RenderInternals.Log.trace({ indent: false, logLevel }, `[add-effect-keyframe] Received request for fileName="${fileName}" effectIndex=${effectIndex} key="${key}" frame=${frame}`);
     const { absolutePath, fileRelativeToRoot } = (0, resolve_file_inside_project_1.resolveFileInsideProject)({
         remotionRoot,