@remotion/cli 3.0.22 → 4.0.0-2x.1

package/dist/chalk/index.d.ts

@@ -0,0 +1,58 @@
+declare type Style = {
+    codes: [number, number];
+    name: string;
+    wrap?: (input: string, newline: boolean) => string;
+};
+declare type Method = (str: string) => string;
+declare type Colors = {
+    enabled: boolean;
+    visible: boolean;
+    styles: Record<string, Style>;
+    keys: Record<string, string[]>;
+    alias?: (name: string, col: string) => void;
+};
+declare type ColorsWithMethods = Colors & {
+    reset: Method;
+    bold: Method;
+    dim: Method;
+    italic: Method;
+    underline: Method;
+    inverse: Method;
+    hidden: Method;
+    strikethrough: Method;
+    black: Method;
+    red: Method;
+    green: Method;
+    yellow: Method;
+    blue: Method;
+    magenta: Method;
+    cyan: Method;
+    white: Method;
+    gray: Method;
+    bgBlack: Method;
+    bgRed: Method;
+    bgGreen: Method;
+    bgYellow: Method;
+    bgBlue: Method;
+    bgMagenta: Method;
+    bgCyan: Method;
+    bgWhite: Method;
+    blackBright: Method;
+    redBright: Method;
+    greenBright: Method;
+    yellowBright: Method;
+    blueBright: Method;
+    magentaBright: Method;
+    cyanBright: Method;
+    whiteBright: Method;
+    bgBlackBright: Method;
+    bgRedBright: Method;
+    bgGreenBright: Method;
+    bgYellowBright: Method;
+    bgBlueBright: Method;
+    bgMagentaBright: Method;
+    bgCyanBright: Method;
+    bgWhiteBright: Method;
+};
+export declare const chalk: ColorsWithMethods;
+export {};

package/dist/chalk/index.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chalk = void 0;
+const hasColor = () => {
+    if (typeof process !== 'undefined') {
+        return process.env.FORCE_COLOR !== '0';
+    }
+    return false;
+};
+exports.chalk = (() => {
+    const colors = {
+        enabled: hasColor(),
+        visible: true,
+        styles: {},
+        keys: {},
+    };
+    const ansi = (st) => {
+        const open = `\u001b[${st.codes[0]}m`;
+        const close = `\u001b[${st.codes[1]}m`;
+        const regex = new RegExp(`\\u001b\\[${st.codes[1]}m`, 'g');
+        st.wrap = (input, newline) => {
+            if (input.includes(close))
+                input = input.replace(regex, close + open);
+            const output = open + input + close;
+            // see https://github.com/chalk/chalk/pull/92, thanks to the
+            // chalk contributors for this fix. However, we've confirmed that
+            // this issue is also present in Windows terminals
+            return newline ? output.replace(/\r*\n/g, `${close}$&${open}`) : output;
+        };
+        return st;
+    };
+    const wrap = (sty, input, newline) => {
+        var _a;
+        return (_a = sty.wrap) === null || _a === void 0 ? void 0 : _a.call(sty, input, newline);
+    };
+    const style = (input, stack) => {
+        if (input === '' || input === null || input === undefined)
+            return '';
+        if (colors.enabled === false)
+            return input;
+        if (colors.visible === false)
+            return '';
+        let str = String(input);
+        const nl = str.includes('\n');
+        let n = stack.length;
+        while (n-- > 0)
+            str = wrap(colors.styles[stack[n]], str, nl);
+        return str;
+    };
+    const define = (name, codes, type) => {
+        colors.styles[name] = ansi({ name, codes });
+        const keys = colors.keys[type] || (colors.keys[type] = []);
+        keys.push(name);
+        Reflect.defineProperty(colors, name, {
+            configurable: true,
+            enumerable: true,
+            set(value) {
+                var _a;
+                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
+            },
+            get() {
+                const color = (input) => style(input, color.stack);
+                Reflect.setPrototypeOf(color, colors);
+                color.stack = this.stack ? this.stack.concat(name) : [name];
+                return color;
+            },
+        });
+    };
+    define('reset', [0, 0], 'modifier');
+    define('bold', [1, 22], 'modifier');
+    define('dim', [2, 22], 'modifier');
+    define('italic', [3, 23], 'modifier');
+    define('underline', [4, 24], 'modifier');
+    define('inverse', [7, 27], 'modifier');
+    define('hidden', [8, 28], 'modifier');
+    define('strikethrough', [9, 29], 'modifier');
+    define('black', [30, 39], 'color');
+    define('red', [31, 39], 'color');
+    define('green', [32, 39], 'color');
+    define('yellow', [33, 39], 'color');
+    define('blue', [34, 39], 'color');
+    define('magenta', [35, 39], 'color');
+    define('cyan', [36, 39], 'color');
+    define('white', [37, 39], 'color');
+    define('gray', [90, 39], 'color');
+    define('grey', [90, 39], 'color');
+    define('bgBlack', [40, 49], 'bg');
+    define('bgRed', [41, 49], 'bg');
+    define('bgGreen', [42, 49], 'bg');
+    define('bgYellow', [43, 49], 'bg');
+    define('bgBlue', [44, 49], 'bg');
+    define('bgMagenta', [45, 49], 'bg');
+    define('bgCyan', [46, 49], 'bg');
+    define('bgWhite', [47, 49], 'bg');
+    define('blackBright', [90, 39], 'bright');
+    define('redBright', [91, 39], 'bright');
+    define('greenBright', [92, 39], 'bright');
+    define('yellowBright', [93, 39], 'bright');
+    define('blueBright', [94, 39], 'bright');
+    define('magentaBright', [95, 39], 'bright');
+    define('cyanBright', [96, 39], 'bright');
+    define('whiteBright', [97, 39], 'bright');
+    define('bgBlackBright', [100, 49], 'bgBright');
+    define('bgRedBright', [101, 49], 'bgBright');
+    define('bgGreenBright', [102, 49], 'bgBright');
+    define('bgYellowBright', [103, 49], 'bgBright');
+    define('bgBlueBright', [104, 49], 'bgBright');
+    define('bgMagentaBright', [105, 49], 'bgBright');
+    define('bgCyanBright', [106, 49], 'bgBright');
+    define('bgWhiteBright', [107, 49], 'bgBright');
+    colors.alias = (name, color) => {
+        // @ts-expect-error
+        const fn = colors[color];
+        if (typeof fn !== 'function') {
+            throw new TypeError('Expected alias to be the name of an existing color (string) or a function');
+        }
+        if (!fn.stack) {
+            Reflect.defineProperty(fn, 'name', { value: name });
+            colors.styles[name] = fn;
+            fn.stack = [name];
+        }
+        Reflect.defineProperty(colors, name, {
+            configurable: true,
+            enumerable: true,
+            set(value) {
+                var _a;
+                (_a = colors.alias) === null || _a === void 0 ? void 0 : _a.call(colors, name, value);
+            },
+            get() {
+                const col = (input) => style(input, col.stack);
+                Reflect.setPrototypeOf(col, colors);
+                col.stack = this.stack ? this.stack.concat(fn.stack) : fn.stack;
+                return col;
+            },
+        });
+    };
+    return colors;
+})();

package/dist/chalk/symbols.d.ts

@@ -0,0 +1,111 @@
+declare const isHyper: boolean;
+declare const isWindows: boolean;
+declare const isLinux: boolean;
+declare const common: {
+    ballotDisabled: string;
+    ballotOff: string;
+    ballotOn: string;
+    bullet: string;
+    bulletWhite: string;
+    fullBlock: string;
+    heart: string;
+    identicalTo: string;
+    line: string;
+    mark: string;
+    middot: string;
+    minus: string;
+    multiplication: string;
+    obelus: string;
+    pencilDownRight: string;
+    pencilRight: string;
+    pencilUpRight: string;
+    percent: string;
+    pilcrow2: string;
+    pilcrow: string;
+    plusMinus: string;
+    question: string;
+    section: string;
+    starsOff: string;
+    starsOn: string;
+    upDownArrow: string;
+};
+declare const windows: {
+    check: string;
+    cross: string;
+    ellipsisLarge: string;
+    ellipsis: string;
+    info: string;
+    questionSmall: string;
+    pointer: string;
+    pointerSmall: string;
+    radioOff: string;
+    radioOn: string;
+    warning: string;
+    ballotDisabled: string;
+    ballotOff: string;
+    ballotOn: string;
+    bullet: string;
+    bulletWhite: string;
+    fullBlock: string;
+    heart: string;
+    identicalTo: string;
+    line: string;
+    mark: string;
+    middot: string;
+    minus: string;
+    multiplication: string;
+    obelus: string;
+    pencilDownRight: string;
+    pencilRight: string;
+    pencilUpRight: string;
+    percent: string;
+    pilcrow2: string;
+    pilcrow: string;
+    plusMinus: string;
+    question: string;
+    section: string;
+    starsOff: string;
+    starsOn: string;
+    upDownArrow: string;
+};
+declare const other: {
+    ballotCross: string;
+    check: string;
+    cross: string;
+    ellipsisLarge: string;
+    ellipsis: string;
+    info: string;
+    questionFull: string;
+    questionSmall: string;
+    pointer: string;
+    pointerSmall: string;
+    radioOff: string;
+    radioOn: string;
+    warning: string;
+    ballotDisabled: string;
+    ballotOff: string;
+    ballotOn: string;
+    bullet: string;
+    bulletWhite: string;
+    fullBlock: string;
+    heart: string;
+    identicalTo: string;
+    line: string;
+    mark: string;
+    middot: string;
+    minus: string;
+    multiplication: string;
+    obelus: string;
+    pencilDownRight: string;
+    pencilRight: string;
+    pencilUpRight: string;
+    percent: string;
+    pilcrow2: string;
+    pilcrow: string;
+    plusMinus: string;
+    question: string;
+    section: string;
+    starsOff: string;
+    starsOn: string;
+    upDownArrow: string;
+};

package/dist/chalk/symbols.js

@@ -0,0 +1,75 @@
+'use strict';
+const isHyper = typeof process !== 'undefined' && process.env.TERM_PROGRAM === 'Hyper';
+const isWindows = typeof process !== 'undefined' && process.platform === 'win32';
+const isLinux = typeof process !== 'undefined' && process.platform === 'linux';
+const common = {
+    ballotDisabled: '☒',
+    ballotOff: '☐',
+    ballotOn: '☑',
+    bullet: '•',
+    bulletWhite: '◦',
+    fullBlock: '█',
+    heart: '❤',
+    identicalTo: '≡',
+    line: '─',
+    mark: '※',
+    middot: '·',
+    minus: '－',
+    multiplication: '×',
+    obelus: '÷',
+    pencilDownRight: '✎',
+    pencilRight: '✏',
+    pencilUpRight: '✐',
+    percent: '%',
+    pilcrow2: '❡',
+    pilcrow: '¶',
+    plusMinus: '±',
+    question: '?',
+    section: '§',
+    starsOff: '☆',
+    starsOn: '★',
+    upDownArrow: '↕',
+};
+const windows = {
+    ...common,
+    check: '√',
+    cross: '×',
+    ellipsisLarge: '...',
+    ellipsis: '...',
+    info: 'i',
+    questionSmall: '?',
+    pointer: '>',
+    pointerSmall: '»',
+    radioOff: '( )',
+    radioOn: '(*)',
+    warning: '‼',
+};
+const other = {
+    ...common,
+    ballotCross: '✘',
+    check: '✔',
+    cross: '✖',
+    ellipsisLarge: '⋯',
+    ellipsis: '…',
+    info: 'ℹ',
+    questionFull: '？',
+    questionSmall: '﹖',
+    pointer: isLinux ? '▸' : '❯',
+    pointerSmall: isLinux ? '‣' : '›',
+    radioOff: '◯',
+    radioOn: '◉',
+    warning: '⚠',
+};
+module.exports = isWindows && !isHyper ? windows : other;
+Reflect.defineProperty(module.exports, 'common', {
+    enumerable: false,
+    value: common,
+});
+Reflect.defineProperty(module.exports, 'windows', {
+    enumerable: false,
+    value: windows,
+});
+Reflect.defineProperty(module.exports, 'other', {
+    enumerable: false,
+    value: other,
+});

package/dist/chalk/utilities.d.ts

@@ -0,0 +1,2 @@
+export declare function stringReplaceAll(string: string, substring: string, replacer: string): string;
+export declare function stringEncaseCRLFWithFirstIndex(string: string, prefix: string, postfix: string, index: number): string;

package/dist/chalk/utilities.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringEncaseCRLFWithFirstIndex = exports.stringReplaceAll = void 0;
+function stringReplaceAll(string, substring, replacer) {
+    let index = string.indexOf(substring);
+    if (index === -1) {
+        return string;
+    }
+    const substringLength = substring.length;
+    let endIndex = 0;
+    let returnValue = '';
+    do {
+        returnValue += string.slice(endIndex, index) + substring + replacer;
+        endIndex = index + substringLength;
+        index = string.indexOf(substring, endIndex);
+    } while (index !== -1);
+    returnValue += string.slice(endIndex);
+    return returnValue;
+}
+exports.stringReplaceAll = stringReplaceAll;
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+    let endIndex = 0;
+    let returnValue = '';
+    do {
+        const gotCR = string[index - 1] === '\r';
+        returnValue +=
+            string.slice(endIndex, gotCR ? index - 1 : index) +
+                prefix +
+                (gotCR ? '\r\n' : '\n') +
+                postfix;
+        endIndex = index + 1;
+        index = string.indexOf('\n', endIndex);
+    } while (index !== -1);
+    returnValue += string.slice(endIndex);
+    return returnValue;
+}
+exports.stringEncaseCRLFWithFirstIndex = stringEncaseCRLFWithFirstIndex;

package/dist/code-frame.d.ts

@@ -1,2 +1,2 @@
-import { ErrorWithStackFrame } from '@remotion/renderer';
+import type { ErrorWithStackFrame } from '@remotion/renderer';
 export declare const printCodeFrameAndStack: (err: ErrorWithStackFrame) => void;

package/dist/code-frame.js

@@ -1,11 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.printCodeFrameAndStack = void 0;
-const chalk_1 = __importDefault(require("chalk"));
 const remotion_1 = require("remotion");
+const chalk_1 = require("./chalk");
 const log_1 = require("./log");
 const makeFileName = (firstFrame) => {
     return [
@@ -24,12 +21,12 @@ const printCodeFrame = (frame) => {
     }
     log_1.Log.info();
     const longestLineNumber = Math.max(...frame.originalScriptCode.map((script) => script.lineNumber)).toString().length;
-    log_1.Log.info('at', chalk_1.default.underline(makeFileName(frame)));
+    log_1.Log.info('at', chalk_1.chalk.underline(makeFileName(frame)));
     const alignLeftAmount = Math.min(...frame.originalScriptCode.map((c) => c.content.length - c.content.trimStart().length));
     log_1.Log.info(`${frame.originalScriptCode
         .map((c) => {
         const content = `${String(c.lineNumber).padStart(longestLineNumber, ' ')} | ${c.content.substring(alignLeftAmount)}`;
-        return c.highlight ? content : chalk_1.default.gray(content);
+        return c.highlight ? content : chalk_1.chalk.gray(content);
     })
         .join('\n')}`);
 };
@@ -38,7 +35,7 @@ const logLine = (frame) => {
     if (!fileName) {
         return;
     }
-    log_1.Log.info(chalk_1.default.gray(['at', frame.originalFunctionName, `${chalk_1.default.blueBright(`(${fileName})`)}`]
+    log_1.Log.info(chalk_1.chalk.gray(['at', frame.originalFunctionName, `${chalk_1.chalk.blueBright(`(${fileName})`)}`]
         .filter(remotion_1.Internals.truthy)
         .join(' ')));
 };
@@ -49,7 +46,7 @@ const printCodeFrameAndStack = (err) => {
         return;
     }
     const firstFrame = err.symbolicatedStackFrames[0];
-    log_1.Log.error(chalk_1.default.bgRed(chalk_1.default.white(` ${err.name} `)), err.message);
+    log_1.Log.error(chalk_1.chalk.bgRed(chalk_1.chalk.white(` ${err.name} `)), err.message);
     printCodeFrame(firstFrame);
     log_1.Log.info();
     for (const frame of err.symbolicatedStackFrames) {

package/dist/download-progress.d.ts

@@ -1,2 +1,2 @@
-import { DownloadProgress } from './progress-bar';
+import type { DownloadProgress } from './progress-bar';
 export declare const makeMultiDownloadProgress: (progresses: DownloadProgress[]) => string | null;

package/dist/editor/components/CompositionSelectorItem.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { TComposition } from 'remotion';
+import type { TComposition } from 'remotion';
 export declare type CompositionSelectorItemType = {
     key: string;
     type: 'composition';

package/dist/editor/components/FramePersistor.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type React from 'react';
 export declare const getCurrentCompositionFromUrl: () => string;
 export declare const persistCurrentFrame: (frame: number) => void;
 export declare const getFrameForComposition: (composition: string) => number;

package/dist/editor/components/GlobalKeybindings.d.ts

@@ -1,2 +1,2 @@
-import React from 'react';
+import type React from 'react';
 export declare const GlobalKeybindings: React.FC;

package/dist/editor/components/InitialCompositionLoader.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
-import { TComposition } from 'remotion';
+import type React from 'react';
+import type { TComposition } from 'remotion';
 export declare const useSelectComposition: () => (c: TComposition) => void;
 export declare const InitialCompositionLoader: React.FC;

package/dist/editor/components/Menu/MenuItem.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ComboboxValue } from '../NewComposition/ComboBox';
+import type { ComboboxValue } from '../NewComposition/ComboBox';
 export declare type MenuId = 'remotion' | 'file' | 'view' | 'help';
 export declare type Menu = {
     id: MenuId;

package/dist/editor/components/Menu/MenuSubItem.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SubMenu } from '../NewComposition/ComboBox';
+import type { SubMenu } from '../NewComposition/ComboBox';
 export declare const MENU_SUBMENU_BUTTON_CLASS_NAME = "remotion-submenu-button";
 export declare type SubMenuActivated = false | 'with-mouse' | 'without-mouse';
 export declare const MenuSubItem: React.FC<{

package/dist/editor/components/Menu/SubMenu.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { SubMenu } from '../NewComposition/ComboBox';
-import { SubMenuActivated } from './MenuSubItem';
+import type { SubMenu } from '../NewComposition/ComboBox';
+import type { SubMenuActivated } from './MenuSubItem';
 export declare const SubMenuComponent: React.FC<{
     portalStyle: React.CSSProperties;
     subMenu: SubMenu;

package/dist/editor/components/NewComposition/CancelButton.d.ts

@@ -1,4 +1,5 @@
-import React, { SVGProps } from 'react';
+import type { SVGProps } from 'react';
+import React from 'react';
 export declare const CancelButton: React.FC<SVGProps<SVGSVGElement> & {
     onPress: () => void;
 }>;

package/dist/editor/components/NewComposition/InputDragger.d.ts

@@ -1,4 +1,5 @@
-import React, { InputHTMLAttributes } from 'react';
+import type { InputHTMLAttributes } from 'react';
+import React from 'react';
 declare type Props = InputHTMLAttributes<HTMLInputElement> & {
     onValueChange: (newVal: number) => void;
 };

package/dist/editor/components/NewComposition/MenuContent.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ComboboxValue } from './ComboBox';
+import type { ComboboxValue } from './ComboBox';
 export declare const MenuContent: React.FC<{
     values: ComboboxValue[];
     onHide: () => void;

package/dist/editor/components/NewComposition/NewComposition.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { CompType } from '../../state/modals';
+import type { CompType } from '../../state/modals';
 declare const NewComposition: React.FC<{
     initialCompType: CompType;
 }>;

package/dist/editor/components/NewComposition/new-comp-layout.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type React from 'react';
 export declare const leftLabel: React.CSSProperties;
 export declare const inputArea: React.CSSProperties;
 export declare const rightLabel: React.CSSProperties;

package/dist/editor/components/PlaybackKeyboardShortcutsManager.d.ts

@@ -1,4 +1,4 @@
-import React from 'react';
+import type React from 'react';
 export declare const PlaybackKeyboardShortcutsManager: React.FC<{
     setPlaybackRate: React.Dispatch<React.SetStateAction<number>>;
 }>;

package/dist/editor/components/PlaybackRatePersistor.d.ts

@@ -1,2 +1,2 @@
-import React from 'react';
+import type React from 'react';
 export declare const PlaybackRatePersistor: React.FC;

package/dist/editor/components/Preview.d.ts

@@ -1,4 +1,4 @@
-import { Size } from '@remotion/player';
+import type { Size } from '@remotion/player';
 import React from 'react';
 export declare const VideoPreview: React.FC<{
     canvasSize: Size;

package/dist/editor/components/SizeSelector.d.ts

@@ -1,4 +1,4 @@
-import { PreviewSize } from '@remotion/player';
+import type { PreviewSize } from '@remotion/player';
 import React from 'react';
 export declare const commonPreviewSizes: PreviewSize[];
 export declare const getPreviewSizeLabel: (previewSize: PreviewSize) => "100%" | "50%" | "25%" | "Fit" | undefined;

package/dist/editor/components/Splitter/SplitterContainer.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SplitterOrientation } from './SplitterContext';
+import type { SplitterOrientation } from './SplitterContext';
 export declare const SplitterContainer: React.FC<{
     orientation: SplitterOrientation;
     maxFlex: number;

package/dist/editor/components/Thumbnail.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { TComposition } from 'remotion';
+import type { TComposition } from 'remotion';
 export declare const Thumbnail: React.FC<{
     composition: TComposition<unknown>;
     targetHeight: number;

package/dist/editor/components/Timeline/TimelineList.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
-import { TimelineActionState, TimelineViewState } from './timeline-state-reducer';
+import type { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
+import type { TimelineActionState, TimelineViewState } from './timeline-state-reducer';
 export declare const TimelineList: React.FC<{
     timeline: TrackWithHash[];
     viewState: TimelineViewState;

package/dist/editor/components/Timeline/TimelineListItem.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { TSequence } from 'remotion';
-import { TimelineActionState } from './timeline-state-reducer';
+import type { TSequence } from 'remotion';
+import type { TimelineActionState } from './timeline-state-reducer';
 export declare const TimelineListItem: React.FC<{
     sequence: TSequence;
     nestedDepth: number;

package/dist/editor/components/Timeline/TimelineSequence.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { TSequence } from 'remotion';
+import type { TSequence } from 'remotion';
 export declare const TimelineSequence: React.FC<{
     s: TSequence;
     fps: number;

package/dist/editor/components/Timeline/TimelineTracks.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
-import { TimelineViewState } from './timeline-state-reducer';
+import type { TrackWithHash } from '../../helpers/get-timeline-sequence-sort-key';
+import type { TimelineViewState } from './timeline-state-reducer';
 export declare const TimelineTracks: React.FC<{
     timeline: TrackWithHash[];
     fps: number;