@remotion/cli 4.0.0-2x.1 → 4.0.0-alpha.111

package/dist/editor/state/render-frame.js

@@ -2,10 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderFrame = void 0;
 const renderFrame = (frame, fps) => {
-    const minutes = Math.floor(frame / fps / 60);
-    const remainingSec = frame - minutes * fps * 60;
+    const hours = Math.floor(frame / fps / 3600);
+    const remainingMinutes = frame - hours * fps * 3600;
+    const minutes = Math.floor(remainingMinutes / 60 / fps);
+    const remainingSec = frame - hours * fps * 3600 - minutes * fps * 60;
     const seconds = Math.floor(remainingSec / fps);
     const frameAfterSec = Math.round(frame % fps);
-    return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}.${String(frameAfterSec).padStart(2, '0')}`;
+    const hoursStr = String(hours);
+    const minutesStr = String(minutes).padStart(2, '0');
+    const secondsStr = String(seconds).padStart(2, '0');
+    const frameStr = String(frameAfterSec).padStart(2, '0');
+    if (hours > 0) {
+        return `${hoursStr}:${minutesStr}:${secondsStr}.${frameStr}`;
+    }
+    return `${minutesStr}:${secondsStr}.${frameStr}`;
 };
 exports.renderFrame = renderFrame;

package/dist/editor/state/sidebar.d.ts

@@ -1,10 +1,13 @@
 import React from 'react';
 export declare type SidebarCollapsedState = 'collapsed' | 'expanded' | 'responsive';
 declare type Context = {
-    sidebarCollapsedState: SidebarCollapsedState;
-    setSidebarCollapsedState: (newState: SidebarCollapsedState) => void;
+    sidebarCollapsedStateLeft: SidebarCollapsedState;
+    setSidebarCollapsedStateLeft: (newState: SidebarCollapsedState) => void;
+    sidebarCollapsedStateRight: SidebarCollapsedState;
+    setSidebarCollapsedStateRight: (newState: SidebarCollapsedState) => void;
 };
-export declare const getSavedCollapsedState: () => SidebarCollapsedState;
+declare type Sidebars = 'left' | 'right';
+export declare const getSavedCollapsedState: (sidebar: Sidebars) => SidebarCollapsedState;
 export declare const SidebarContext: React.Context<Context>;
 export declare const SidebarContextProvider: React.FC<{
     children: React.ReactNode;

package/dist/editor/state/sidebar.js

@@ -3,9 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SidebarContextProvider = exports.SidebarContext = exports.getSavedCollapsedState = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
-const storageKey = 'remotion.sidebarCollapsing';
-const getSavedCollapsedState = () => {
-    const state = window.localStorage.getItem(storageKey);
+const storageKey = (sidebar) => {
+    if (sidebar === 'right') {
+        return 'remotion.sidebarRightCollapsing';
+    }
+    return 'remotion.sidebarCollapsing';
+};
+const getSavedCollapsedState = (sidebar) => {
+    const state = window.localStorage.getItem(storageKey(sidebar));
     if (state === 'collapsed') {
         return 'collapsed';
     }
@@ -15,26 +20,36 @@ const getSavedCollapsedState = () => {
     return 'responsive';
 };
 exports.getSavedCollapsedState = getSavedCollapsedState;
-const setSavedCollapsedState = (type) => {
-    window.localStorage.setItem(storageKey, type);
+const setSavedCollapsedState = (type, sidebar) => {
+    window.localStorage.setItem(storageKey(sidebar), type);
 };
 exports.SidebarContext = (0, react_1.createContext)({
-    sidebarCollapsedState: 'collapsed',
-    setSidebarCollapsedState: () => {
+    sidebarCollapsedStateLeft: 'collapsed',
+    setSidebarCollapsedStateLeft: () => {
+        throw new Error('sidebar collapsed state');
+    },
+    sidebarCollapsedStateRight: 'collapsed',
+    setSidebarCollapsedStateRight: () => {
         throw new Error('sidebar collapsed state');
     },
 });
 const SidebarContextProvider = ({ children }) => {
-    const [sidebarCollapsedState, setSidebarCollapsedState] = (0, react_1.useState)(() => (0, exports.getSavedCollapsedState)());
+    const [sidebarCollapsedStateLeft, setSidebarCollapsedStateLeft] = (0, react_1.useState)(() => (0, exports.getSavedCollapsedState)('left'));
+    const [sidebarCollapsedStateRight, setSidebarCollapsedStateRight] = (0, react_1.useState)(() => (0, exports.getSavedCollapsedState)('right'));
     const value = (0, react_1.useMemo)(() => {
         return {
-            setSidebarCollapsedState: (state) => {
-                setSidebarCollapsedState(state);
-                setSavedCollapsedState(state);
+            sidebarCollapsedStateLeft,
+            sidebarCollapsedStateRight,
+            setSidebarCollapsedStateLeft: (state) => {
+                setSidebarCollapsedStateLeft(state);
+                setSavedCollapsedState(state, 'left');
+            },
+            setSidebarCollapsedStateRight: (state) => {
+                setSidebarCollapsedStateRight(state);
+                setSavedCollapsedState(state, 'right');
             },
-            sidebarCollapsedState,
         };
-    }, [sidebarCollapsedState]);
+    }, [sidebarCollapsedStateLeft, sidebarCollapsedStateRight]);
     return ((0, jsx_runtime_1.jsx)(exports.SidebarContext.Provider, { value: value, children: children }));
 };
 exports.SidebarContextProvider = SidebarContextProvider;

package/dist/editor/state/timeline-zoom.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export declare const TIMELINE_MIN_ZOOM = 1;
+export declare const TIMELINE_MAX_ZOOM = 5;
+export declare const TimelineZoomCtx: React.Context<{
+    zoom: number;
+    setZoom: (prev: (prevZoom: number) => number) => void;
+}>;
+export declare const TimelineZoomContext: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/editor/state/timeline-zoom.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimelineZoomContext = exports.TimelineZoomCtx = exports.TIMELINE_MAX_ZOOM = exports.TIMELINE_MIN_ZOOM = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const imperative_state_1 = require("../components/Timeline/imperative-state");
+const timeline_scroll_logic_1 = require("../components/Timeline/timeline-scroll-logic");
+exports.TIMELINE_MIN_ZOOM = 1;
+exports.TIMELINE_MAX_ZOOM = 5;
+exports.TimelineZoomCtx = (0, react_1.createContext)({
+    zoom: -1,
+    setZoom: () => {
+        throw new Error('has no context');
+    },
+});
+const TimelineZoomContext = ({ children }) => {
+    const [zoom, setZoom] = (0, react_1.useState)(exports.TIMELINE_MIN_ZOOM);
+    const value = (0, react_1.useMemo)(() => {
+        return {
+            zoom,
+            setZoom: (callback) => {
+                setZoom((prevZoom) => {
+                    const newZoomWithFloatingPointErrors = Math.min(exports.TIMELINE_MAX_ZOOM, Math.max(exports.TIMELINE_MIN_ZOOM, callback(prevZoom)));
+                    const newZoom = Math.round(newZoomWithFloatingPointErrors * 10) / 10;
+                    (0, timeline_scroll_logic_1.zoomAndPreserveCursor)({
+                        oldZoom: prevZoom,
+                        newZoom,
+                        currentDurationInFrames: (0, imperative_state_1.getCurrentDuration)(),
+                        currentFrame: (0, imperative_state_1.getCurrentFrame)(),
+                    });
+                    return newZoom;
+                });
+            },
+        };
+    }, [zoom]);
+    return ((0, jsx_runtime_1.jsx)(exports.TimelineZoomCtx.Provider, { value: value, children: children }));
+};
+exports.TimelineZoomContext = TimelineZoomContext;

package/dist/editor/state/z-index.js

@@ -12,7 +12,15 @@ exports.ZIndexContext = (0, react_1.createContext)({
 const EscapeHook = ({ onEscape }) => {
     const keybindings = (0, use_keybinding_1.useKeybinding)();
     (0, react_1.useEffect)(() => {
-        const escape = keybindings.registerKeybinding('keydown', 'Escape', onEscape);
+        const escape = keybindings.registerKeybinding({
+            event: 'keydown',
+            key: 'Escape',
+            callback: onEscape,
+            commandCtrlKey: false,
+            preventDefault: true,
+            // To dismiss the Quick Switcher menu if input is focused
+            triggerIfInputFieldFocused: true,
+        });
         return () => {
             escape.unregister();
         };
@@ -29,20 +37,38 @@ const HigherZIndex = ({ children, onEscape, onOutsideClick }) => {
         return () => highestContext.unregisterZIndex(currentIndex);
     }, [currentIndex, highestContext]);
     (0, react_1.useEffect)(() => {
-        const listener = (e) => {
+        let onUp = null;
+        const listener = (downEvent) => {
             var _a;
-            const outsideClick = !((_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.contains(e.target));
-            if (outsideClick &&
-                highestContext.highestIndex === currentIndex &&
-                !(0, input_dragger_click_lock_1.getClickLock)() &&
-                // Don't trigger if that click removed that node
-                document.contains(e.target)) {
-                e.stopPropagation();
-                onOutsideClick();
+            const outsideClick = !((_a = containerRef.current) === null || _a === void 0 ? void 0 : _a.contains(downEvent.target));
+            if (!outsideClick) {
+                return;
             }
+            onUp = (upEvent) => {
+                if (outsideClick &&
+                    highestContext.highestIndex === currentIndex &&
+                    !(0, input_dragger_click_lock_1.getClickLock)() &&
+                    // Don't trigger if that click removed that node
+                    document.contains(upEvent.target)) {
+                    upEvent.stopPropagation();
+                    onOutsideClick();
+                }
+            };
+            window.addEventListener('pointerup', onUp, { once: true });
+        };
+        // If a menu is opened, then this component will also still receive the pointerdown event.
+        // However we may not interpret it as a outside click, so we need to wait for the next tick
+        requestAnimationFrame(() => {
+            window.addEventListener('pointerdown', listener);
+        });
+        return () => {
+            onUp = null;
+            if (onUp) {
+                // @ts-expect-error
+                window.removeEventListener('pointerup', onUp, { once: true });
+            }
+            return window.removeEventListener('pointerdown', listener);
         };
-        window.addEventListener('click', listener);
-        return () => window.removeEventListener('click', listener);
     }, [currentIndex, highestContext.highestIndex, onOutsideClick]);
     const value = (0, react_1.useMemo)(() => {
         return {

package/dist/entry-point.d.ts

@@ -0,0 +1,5 @@
+export declare const findEntryPoint: (args: string[], remotionRoot: string) => {
+    file: string | null;
+    remainingArgs: string[];
+    reason: string;
+};

package/dist/entry-point.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEntryPoint = void 0;
+const renderer_1 = require("@remotion/renderer");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const log_1 = require("./log");
+const candidates = [
+    path_1.default.join('src', 'index.ts'),
+    path_1.default.join('src', 'index.tsx'),
+    path_1.default.join('src', 'index.js'),
+    path_1.default.join('remotion', 'index.tsx'),
+    path_1.default.join('remotion', 'index.ts'),
+    path_1.default.join('remotion', 'index.js'),
+];
+const findCommonPath = (remotionRoot) => {
+    return candidates.find((candidate) => (0, fs_1.existsSync)(path_1.default.resolve(remotionRoot, candidate)));
+};
+const findEntryPoint = (args, remotionRoot) => {
+    const result = findEntryPointInner(args, remotionRoot);
+    if (result.file === null) {
+        return result;
+    }
+    if (renderer_1.RenderInternals.isServeUrl(result.file)) {
+        return result;
+    }
+    if (!(0, fs_1.existsSync)(result.file)) {
+        throw new Error(`${result.file} was chosen as the entry point (reason = ${result.reason}) but it does not exist.`);
+    }
+    if ((0, fs_1.lstatSync)(result.file).isDirectory()) {
+        throw new Error(`${result.file} was chosen as the entry point (reason = ${result.reason}) but it is a directory - it needs to be a file.`);
+    }
+    return result;
+};
+exports.findEntryPoint = findEntryPoint;
+const findEntryPointInner = (args, remotionRoot) => {
+    // 1st priority: Explicitly passed entry point
+    let file = args[0];
+    if (file) {
+        log_1.Log.verbose('Checking if', file, 'is the entry file');
+        const cwdResolution = path_1.default.resolve(process.cwd(), file);
+        const remotionRootResolution = path_1.default.resolve(remotionRoot, file);
+        // Checking if file was found in CWD
+        if ((0, fs_1.existsSync)(cwdResolution)) {
+            return {
+                file: cwdResolution,
+                remainingArgs: args.slice(1),
+                reason: 'argument passed - found in cwd',
+            };
+        }
+        // Checking if file was found in remotion root
+        if ((0, fs_1.existsSync)(remotionRootResolution)) {
+            return {
+                file: remotionRootResolution,
+                remainingArgs: args.slice(1),
+                reason: 'argument passed - found in root',
+            };
+        }
+        if (renderer_1.RenderInternals.isServeUrl(file)) {
+            return { file, remainingArgs: args.slice(1), reason: 'argument passed' };
+        }
+    }
+    // 2nd priority: Config file
+    file = config_1.ConfigInternals.getEntryPoint();
+    if (file) {
+        log_1.Log.verbose('Entry point from config file is', file);
+        return {
+            file: path_1.default.resolve(remotionRoot, file),
+            remainingArgs: args,
+            reason: 'config file',
+        };
+    }
+    // 3rd priority: Common paths
+    const found = findCommonPath(remotionRoot);
+    if (found) {
+        const absolutePath = path_1.default.resolve(remotionRoot, found);
+        log_1.Log.verbose('Selected', absolutePath, 'as the entry point because file exists and is a common entry point and no entry point was explicitly selected');
+        return {
+            file: absolutePath,
+            remainingArgs: args,
+            reason: 'common paths',
+        };
+    }
+    return { file: null, remainingArgs: args, reason: 'none found' };
+};

package/dist/event-source-events.d.ts

@@ -0,0 +1,28 @@
+import type { StaticFile } from 'remotion';
+import type { RenderJob } from './preview-server/render-queue/job';
+export declare type EventSourceEvent = {
+    type: 'new-input-props';
+    newProps: object;
+} | {
+    type: 'init';
+    clientId: string;
+} | {
+    type: 'new-env-variables';
+    newEnvVariables: Record<string, string>;
+} | {
+    type: 'render-queue-updated';
+    queue: RenderJob[];
+} | {
+    type: 'render-job-failed';
+    compositionId: string;
+    error: Error;
+} | {
+    type: 'watched-file-undeleted';
+    file: string;
+} | {
+    type: 'watched-file-deleted';
+    file: string;
+} | {
+    type: 'new-public-folder';
+    files: StaticFile[];
+};

package/dist/event-source-events.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/event-source.d.ts

@@ -0,0 +1,3 @@
+import type { EventSourceEvent } from './event-source-events';
+export declare const subscribeToEvent: (type: EventSourceEvent['type'], listener: (event: EventSourceEvent) => void) => () => void;
+export declare const openEventSource: () => void;

package/dist/event-source.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openEventSource = exports.subscribeToEvent = void 0;
+const NotificationCenter_1 = require("./editor/components/Notifications/NotificationCenter");
+const context_1 = require("./editor/components/RenderQueue/context");
+const client_id_1 = require("./editor/helpers/client-id");
+let source = null;
+let listeners = [];
+const subscribeToEvent = (type, listener) => {
+    listeners.push({ type, listener });
+    return () => {
+        listeners = listeners.filter((l) => l.type !== type || l.listener !== listener);
+    };
+};
+exports.subscribeToEvent = subscribeToEvent;
+const openEventSource = () => {
+    source = new EventSource('/events');
+    source.addEventListener('message', (event) => {
+        var _a, _b;
+        const newEvent = JSON.parse(event.data);
+        if (newEvent.type === 'new-input-props' ||
+            newEvent.type === 'new-env-variables') {
+            window.location.reload();
+        }
+        if (newEvent.type === 'init') {
+            (_a = client_id_1.previewServerConnectionRef.current) === null || _a === void 0 ? void 0 : _a.set({
+                type: 'connected',
+                clientId: newEvent.clientId,
+            });
+        }
+        if (newEvent.type === 'render-queue-updated') {
+            (_b = context_1.renderJobsRef.current) === null || _b === void 0 ? void 0 : _b.updateRenderJobs(newEvent.queue);
+        }
+        if (newEvent.type === 'render-job-failed') {
+            (0, NotificationCenter_1.sendErrorNotification)(`Rendering "${newEvent.compositionId}" failed`);
+        }
+        if (newEvent.type === 'new-public-folder') {
+            window.remotion_staticFiles = newEvent.files;
+        }
+        listeners.forEach((l) => {
+            if (l.type === newEvent.type) {
+                l.listener(newEvent);
+            }
+        });
+    });
+    source.addEventListener('open', () => {
+        source.addEventListener('error', () => {
+            var _a;
+            (_a = client_id_1.previewServerConnectionRef.current) === null || _a === void 0 ? void 0 : _a.set({ type: 'disconnected' });
+            // Display an error message that the preview server has disconnected.
+            source === null || source === void 0 ? void 0 : source.close();
+            // Retry later
+            setTimeout(() => {
+                (0, exports.openEventSource)();
+            }, 1000);
+        }, { once: true });
+    });
+};
+exports.openEventSource = openEventSource;

package/dist/ffmpeg.d.ts

@@ -0,0 +1,2 @@
+export declare const ffmpegCommand: (_root: string, args: string[]) => never;
+export declare const ffprobeCommand: (_root: string, args: string[]) => never;

package/dist/ffmpeg.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ffprobeCommand = exports.ffmpegCommand = void 0;
+const renderer_1 = require("@remotion/renderer");
+const child_process_1 = require("child_process");
+const ffmpegCommand = (_root, args) => {
+    const done = (0, child_process_1.spawnSync)(renderer_1.RenderInternals.getExecutablePath('ffmpeg'), args, {
+        ...renderer_1.RenderInternals.callFfExtraOptions(),
+        stdio: 'inherit',
+    });
+    process.exit(done.status);
+};
+exports.ffmpegCommand = ffmpegCommand;
+const ffprobeCommand = (_root, args) => {
+    const done = (0, child_process_1.spawnSync)(renderer_1.RenderInternals.getExecutablePath('ffprobe'), args, {
+        ...renderer_1.RenderInternals.callFfExtraOptions(),
+        stdio: 'inherit',
+    });
+    process.exit(done.status);
+};
+exports.ffprobeCommand = ffprobeCommand;

package/dist/file-watcher.d.ts

@@ -0,0 +1,9 @@
+declare type FileChangeType = 'created' | 'deleted' | 'changed';
+export declare const installFileWatcher: ({ file, onChange, }: {
+    file: string;
+    onChange: (type: FileChangeType) => void;
+}) => {
+    exists: boolean;
+    unwatch: () => void;
+};
+export {};

package/dist/file-watcher.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installFileWatcher = void 0;
+const fs_1 = __importDefault(require("fs"));
+const installFileWatcher = ({ file, onChange, }) => {
+    const existedAtBeginning = fs_1.default.existsSync(file);
+    let existedBefore = existedAtBeginning;
+    const listener = () => {
+        const existsNow = fs_1.default.existsSync(file);
+        if (!existedBefore && existsNow) {
+            onChange('created');
+            existedBefore = true;
+            return;
+        }
+        if (existedBefore && !existsNow) {
+            onChange('deleted');
+            existedBefore = false;
+            return;
+        }
+        if (existsNow) {
+            onChange('changed');
+        }
+    };
+    fs_1.default.watchFile(file, { interval: 100 }, listener);
+    return {
+        exists: existedAtBeginning,
+        unwatch: () => {
+            fs_1.default.unwatchFile(file, listener);
+        },
+    };
+};
+exports.installFileWatcher = installFileWatcher;

package/dist/format-bytes.d.ts

@@ -0,0 +1,6 @@
+export declare const formatBytes: (number: number, options?: Intl.NumberFormatOptions & {
+    locale: string;
+    bits?: boolean;
+    binary?: boolean;
+    signed: boolean;
+}) => string;

package/dist/format-bytes.js

@@ -0,0 +1,103 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = void 0;
+const BYTE_UNITS = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+const BIBYTE_UNITS = [
+    'B',
+    'kiB',
+    'MiB',
+    'GiB',
+    'TiB',
+    'PiB',
+    'EiB',
+    'ZiB',
+    'YiB',
+];
+const BIT_UNITS = [
+    'b',
+    'kbit',
+    'Mbit',
+    'Gbit',
+    'Tbit',
+    'Pbit',
+    'Ebit',
+    'Zbit',
+    'Ybit',
+];
+const BIBIT_UNITS = [
+    'b',
+    'kibit',
+    'Mibit',
+    'Gibit',
+    'Tibit',
+    'Pibit',
+    'Eibit',
+    'Zibit',
+    'Yibit',
+];
+/*
+Formats the given number using `Number#toLocaleString`.
+- If locale is a string, the value is expected to be a locale-key (for example: `de`).
+- If locale is true, the system default locale is used for translation.
+- If no value for locale is specified, the number is returned unmodified.
+*/
+const toLocaleString = (number, locale, options) => {
+    if (typeof locale === 'string' || Array.isArray(locale)) {
+        return number.toLocaleString(locale, options);
+    }
+    if (locale === true || options !== undefined) {
+        return number.toLocaleString(undefined, options);
+    }
+    return String(number);
+};
+const formatBytes = (number, options = {
+    locale: 'en-US',
+    signed: false,
+    maximumFractionDigits: 1,
+}) => {
+    if (!Number.isFinite(number)) {
+        throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
+    }
+    options = { bits: false, binary: false, ...options };
+    const UNITS = options.bits
+        ? options.binary
+            ? BIBIT_UNITS
+            : BIT_UNITS
+        : options.binary
+            ? BIBYTE_UNITS
+            : BYTE_UNITS;
+    if (options.signed && number === 0) {
+        return `0 $ {
+            UNITS[0]
+        }`;
+    }
+    const isNegative = number < 0;
+    const prefix = isNegative ? '-' : options.signed ? '+' : '';
+    if (isNegative) {
+        number = -number;
+    }
+    let localeOptions;
+    if (options.minimumFractionDigits !== undefined) {
+        localeOptions = {
+            minimumFractionDigits: options.minimumFractionDigits,
+        };
+    }
+    if (options.maximumFractionDigits !== undefined) {
+        localeOptions = {
+            maximumFractionDigits: options.maximumFractionDigits,
+            ...localeOptions,
+        };
+    }
+    if (number < 1) {
+        const numString = toLocaleString(number, options.locale, localeOptions);
+        return prefix + numString + ' ' + UNITS[0];
+    }
+    const exponent = Math.min(Math.floor(options.binary
+        ? Math.log(number) / Math.log(1024)
+        : Math.log10(number) / 3), UNITS.length - 1);
+    number /= (options.binary ? 1024 : 1000) ** exponent;
+    const numberString = toLocaleString(Number(number), options.locale, localeOptions);
+    const unit = UNITS[exponent];
+    return prefix + numberString + ' ' + unit;
+};
+exports.formatBytes = formatBytes;

package/dist/get-audio-codec.d.ts

@@ -0,0 +1,2 @@
+import type { AudioCodec } from '@remotion/renderer';
+export declare const getResolvedAudioCodec: () => AudioCodec | null;

package/dist/get-audio-codec.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolvedAudioCodec = void 0;
+const config_1 = require("./config");
+const parse_command_line_1 = require("./parse-command-line");
+const getResolvedAudioCodec = () => {
+    var _a;
+    return (_a = parse_command_line_1.parsedCli['audio-codec']) !== null && _a !== void 0 ? _a : config_1.ConfigInternals.getAudioCodec();
+};
+exports.getResolvedAudioCodec = getResolvedAudioCodec;