@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/ffmpeg-filter-file.js

@@ -0,0 +1,70 @@
+"use strict";
+// While an FFMPEG filter can be passed directly, if it's too long
+// we run into Windows command length limits.
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFfmpegFilterFileStr = exports.makeFfmpegFilterFile = void 0;
+const node_fs_1 = __importStar(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const makeFfmpegFilterFile = (complexFilter, downloadMap) => {
+    if (complexFilter.filter === null) {
+        return {
+            file: null,
+            cleanup: () => undefined,
+        };
+    }
+    return (0, exports.makeFfmpegFilterFileStr)(complexFilter.filter, downloadMap);
+};
+exports.makeFfmpegFilterFile = makeFfmpegFilterFile;
+const makeFfmpegFilterFileStr = async (complexFilter, downloadMap) => {
+    const random = Math.random().toString().replace('.', '');
+    const filterFile = node_path_1.default.join(downloadMap.complexFilter, 'complex-filter-' + random + '.txt');
+    // Race condition: Sometimes the download map is deleted before the file is written.
+    // Can remove this once the original bug has been fixed
+    if (!(0, node_fs_1.existsSync)(downloadMap.complexFilter)) {
+        node_fs_1.default.mkdirSync(downloadMap.complexFilter, { recursive: true });
+    }
+    await node_fs_1.default.promises.writeFile(filterFile, complexFilter);
+    return {
+        file: filterFile,
+        cleanup: () => {
+            node_fs_1.default.unlinkSync(filterFile);
+        },
+    };
+};
+exports.makeFfmpegFilterFileStr = makeFfmpegFilterFileStr;

package/package/dist/ffmpeg-override.d.ts

@@ -0,0 +1,4 @@
+export type FfmpegOverrideFn = (info: {
+    type: 'pre-stitcher' | 'stitcher';
+    args: string[];
+}) => string[];

package/package/dist/ffmpeg-override.js

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

package/package/dist/file-extensions.d.ts

@@ -0,0 +1,14 @@
+import type { Codec } from './codec';
+import type { supportedAudioCodecs } from './options/audio-codec';
+export type FileExtension = 'aac' | '3gp' | 'm4a' | 'm4b' | 'mpg' | 'mpeg' | 'mkv' | 'mp4' | 'gif' | 'hevc' | 'mp3' | 'mov' | 'mxf' | 'wav' | 'ts' | 'webm';
+export declare const defaultFileExtensionMap: {
+    [key in Codec]: {
+        default: FileExtension;
+        forAudioCodec: {
+            [k in (typeof supportedAudioCodecs)[key][number]]: {
+                possible: FileExtension[];
+                default: FileExtension;
+            };
+        };
+    };
+};

package/package/dist/file-extensions.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFileExtensionMap = void 0;
+exports.defaultFileExtensionMap = {
+    'h264-mkv': {
+        default: 'mkv',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            mp3: { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    'h264-ts': {
+        default: 'ts',
+        forAudioCodec: {
+            'pcm-16': { possible: ['ts'], default: 'ts' },
+            aac: { possible: ['ts'], default: 'ts' },
+        },
+    },
+    aac: {
+        default: 'aac',
+        forAudioCodec: {
+            aac: {
+                possible: ['aac', '3gp', 'm4a', 'm4b', 'mpg', 'mpeg'],
+                default: 'aac',
+            },
+            'pcm-16': {
+                possible: ['wav'],
+                default: 'wav',
+            },
+        },
+    },
+    gif: {
+        default: 'gif',
+        forAudioCodec: {},
+    },
+    h264: {
+        default: 'mp4',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv', 'mov'], default: 'mkv' },
+            aac: { possible: ['mp4', 'mkv', 'mov'], default: 'mp4' },
+            mp3: { possible: ['mp4', 'mkv', 'mov'], default: 'mp4' },
+        },
+    },
+    h265: {
+        default: 'mp4',
+        forAudioCodec: {
+            aac: { possible: ['mp4', 'mkv', 'hevc'], default: 'mp4' },
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+        },
+    },
+    mp3: {
+        default: 'mp3',
+        forAudioCodec: {
+            mp3: { possible: ['mp3'], default: 'mp3' },
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+    prores: {
+        default: 'mov',
+        forAudioCodec: {
+            aac: { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+            'pcm-16': { possible: ['mov', 'mkv', 'mxf'], default: 'mov' },
+        },
+    },
+    vp8: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    vp9: {
+        default: 'webm',
+        forAudioCodec: {
+            'pcm-16': { possible: ['mkv'], default: 'mkv' },
+            opus: { possible: ['webm'], default: 'webm' },
+        },
+    },
+    wav: {
+        default: 'wav',
+        forAudioCodec: {
+            'pcm-16': { possible: ['wav'], default: 'wav' },
+        },
+    },
+};

package/package/dist/filter-asset-types.d.ts

@@ -0,0 +1,8 @@
+import type { AudioOrVideoAsset, InlineAudioAsset, TRenderAsset } from 'remotion/no-react';
+import type { EmittedArtifact } from './serialize-artifact';
+export declare const onlyAudioAndVideoAssets: (assets: TRenderAsset[]) => AudioOrVideoAsset[];
+export declare const onlyArtifact: ({ assets, frameBuffer, }: {
+    assets: TRenderAsset[];
+    frameBuffer: Buffer | null;
+}) => EmittedArtifact[];
+export declare const onlyInlineAudio: (assets: TRenderAsset[]) => InlineAudioAsset[];

package/package/dist/filter-asset-types.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onlyInlineAudio = exports.onlyArtifact = exports.onlyAudioAndVideoAssets = void 0;
+const truthy_1 = require("./truthy");
+const onlyAudioAndVideoAssets = (assets) => {
+    return assets.filter((asset) => asset.type === 'audio' || asset.type === 'video');
+};
+exports.onlyAudioAndVideoAssets = onlyAudioAndVideoAssets;
+const onlyArtifact = ({ assets, frameBuffer, }) => {
+    const artifacts = assets.filter((asset) => asset.type === 'artifact');
+    return artifacts
+        .map((artifact) => {
+        if (artifact.contentType === 'binary' ||
+            artifact.contentType === 'text') {
+            return {
+                frame: artifact.frame,
+                content: artifact.content,
+                filename: artifact.filename,
+                downloadBehavior: artifact.downloadBehavior,
+            };
+        }
+        if (artifact.contentType === 'thumbnail') {
+            if (frameBuffer === null) {
+                // A thumbnail artifact was defined to be emitted, but the output was not a video.
+                // Also, in Lambda, there are extra frames which are not video frames.
+                // This could happen if a thumbnail is unconditionally emitted.
+                return null;
+            }
+            return {
+                frame: artifact.frame,
+                content: new Uint8Array(frameBuffer),
+                filename: artifact.filename,
+                downloadBehavior: artifact.downloadBehavior,
+            };
+        }
+        throw new Error('Unknown artifact type: ' + artifact);
+    })
+        .filter(truthy_1.truthy);
+};
+exports.onlyArtifact = onlyArtifact;
+const onlyInlineAudio = (assets) => {
+    return assets.filter((asset) => asset.type === 'inline-audio');
+};
+exports.onlyInlineAudio = onlyInlineAudio;

package/package/dist/find-closest-package-json.d.ts

@@ -0,0 +1,2 @@
+export declare const findClosestPackageJson: () => string | null;
+export declare const findRemotionRoot: () => string;

package/package/dist/find-closest-package-json.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findRemotionRoot = exports.findClosestPackageJson = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const recursionLimit = 5;
+const findClosestPackageJson = () => {
+    let currentDir = process.cwd();
+    let possiblePackageJson = '';
+    for (let i = 0; i < recursionLimit; i++) {
+        possiblePackageJson = node_path_1.default.join(currentDir, 'package.json');
+        const exists = node_fs_1.default.existsSync(possiblePackageJson);
+        if (exists) {
+            return possiblePackageJson;
+        }
+        currentDir = node_path_1.default.dirname(currentDir);
+    }
+    return null;
+};
+exports.findClosestPackageJson = findClosestPackageJson;
+const findRemotionRoot = () => {
+    const closestPackageJson = (0, exports.findClosestPackageJson)();
+    if (closestPackageJson === null) {
+        return process.cwd();
+    }
+    return node_path_1.default.dirname(closestPackageJson);
+};
+exports.findRemotionRoot = findRemotionRoot;

package/package/dist/format-logs.d.ts

@@ -0,0 +1,3 @@
+import type { DevtoolsRemoteObject, ObjectPreview } from './browser/devtools-types';
+export declare const formatRemoteObject: (remoteObject: DevtoolsRemoteObject) => string;
+export declare const formatObjectPreview: (preview: ObjectPreview) => string;

package/package/dist/format-logs.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatObjectPreview = exports.formatRemoteObject = void 0;
+const no_react_1 = require("remotion/no-react");
+const chalk_1 = require("./chalk");
+const formatRemoteObject = (remoteObject) => {
+    if (remoteObject.preview) {
+        return (0, exports.formatObjectPreview)(remoteObject.preview);
+    }
+    if (remoteObject.type === 'string') {
+        const isDelayRenderClear = remoteObject.value.includes(no_react_1.NoReactInternals.DELAY_RENDER_CLEAR_TOKEN);
+        if (isDelayRenderClear) {
+            return chalk_1.chalk.gray(`${remoteObject.value}`);
+        }
+        return `${remoteObject.value}`;
+    }
+    if (remoteObject.type === 'number') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${remoteObject.value}`);
+    }
+    if (remoteObject.type === 'function') {
+        return chalk_1.chalk.cyan(String(remoteObject.description));
+    }
+    if (remoteObject.type === 'object') {
+        if (remoteObject.subtype === 'null') {
+            return `null`;
+        }
+        return chalk_1.chalk.reset(`Object`);
+    }
+    if (remoteObject.type === 'symbol') {
+        return chalk_1.chalk.green(`${remoteObject.description}`);
+    }
+    if (remoteObject.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unhandled remote object');
+};
+exports.formatRemoteObject = formatRemoteObject;
+const formatObjectPreview = (preview) => {
+    if (typeof preview === 'undefined') {
+        return '';
+    }
+    if (preview.type === 'object') {
+        if (preview.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(preview.description))} }`);
+        }
+        const properties = preview.properties.map((property) => {
+            return chalk_1.chalk.reset(`${property.name}: ${formatProperty(property)}`);
+        });
+        if (preview.subtype === 'array') {
+            if (preview.overflow) {
+                return chalk_1.chalk.reset(`[ ${preview.properties
+                    .map((p) => formatProperty(p))
+                    .join(', ')}, …]`);
+            }
+            return chalk_1.chalk.reset(`[ ${preview.properties.map((p) => formatProperty(p)).join(', ')} ]`);
+        }
+        if (preview.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'dataview') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'generator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'iterator') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'map') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'node') {
+            return chalk_1.chalk.magenta(`<${preview.description}>`);
+        }
+        if (preview.subtype === 'null') {
+            return chalk_1.chalk.white(String(preview.description));
+        }
+        if (preview.subtype === 'promise') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'proxy') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'regexp') {
+            return chalk_1.chalk.red(String(preview.description));
+        }
+        if (preview.subtype === 'set') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'error') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'weakset') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (preview.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(String(preview.description));
+        }
+        if (properties.length === 0) {
+            return chalk_1.chalk.reset('{}');
+        }
+        if (preview.overflow) {
+            return chalk_1.chalk.reset(`{ ${properties.join(', ')}, …}`);
+        }
+        return chalk_1.chalk.reset(`{ ${properties.join(', ')} }`);
+    }
+    return '';
+};
+exports.formatObjectPreview = formatObjectPreview;
+const formatProperty = (property) => {
+    if (property.type === 'string') {
+        return chalk_1.chalk.green(`"${property.value}"`);
+    }
+    if (property.type === 'object') {
+        if (!property.subtype && property.value === 'Object') {
+            return chalk_1.chalk.reset(`{…}`);
+        }
+        if (property.subtype === 'date') {
+            return chalk_1.chalk.reset(`Date { ${chalk_1.chalk.magenta(String(property.value))} }`);
+        }
+        if (property.subtype === 'arraybuffer') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'array') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'dataview') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'error') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'generator') {
+            return chalk_1.chalk.reset(`[generator ${property.value}]`);
+        }
+        if (property.subtype === 'iterator') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'map') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'node') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'null') {
+            return chalk_1.chalk.white(`${property.value}`);
+        }
+        if (property.subtype === 'promise') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'proxy') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'regexp') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'set') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'typedarray') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'wasmvalue') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'webassemblymemory') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakmap') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        if (property.subtype === 'weakset') {
+            return chalk_1.chalk.reset(`${property.value}`);
+        }
+        return chalk_1.chalk.reset(`${property.value}`);
+    }
+    if (property.type === 'accessor') {
+        return chalk_1.chalk.gray(`get()`);
+    }
+    if (property.type === 'bigint') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'boolean') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'function') {
+        return chalk_1.chalk.cyan(`Function`);
+    }
+    if (property.type === 'number') {
+        return chalk_1.chalk.yellow(`${property.value}`);
+    }
+    if (property.type === 'symbol') {
+        return chalk_1.chalk.green(`${property.value}`);
+    }
+    if (property.type === 'undefined') {
+        return chalk_1.chalk.gray(`undefined`);
+    }
+    throw new Error('unexpected property type ' + JSON.stringify(property));
+};

package/package/dist/frame-range.d.ts

@@ -0,0 +1,2 @@
+export type FrameRange = number | [number, number];
+export declare const validateFrameRange: (frameRange: FrameRange | null) => void;

package/package/dist/frame-range.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFrameRange = void 0;
+const validateFrameRange = (frameRange) => {
+    if (frameRange === null) {
+        return;
+    }
+    if (typeof frameRange === 'number') {
+        if (frameRange < 0) {
+            throw new TypeError('Frame must be a non-negative number, got ' + frameRange);
+        }
+        if (!Number.isFinite(frameRange)) {
+            throw new TypeError('Frame must be a finite number, got ' + frameRange);
+        }
+        if (!Number.isInteger(frameRange)) {
+            throw new Error(`Frame must be an integer, but got a float (${frameRange})`);
+        }
+        return;
+    }
+    if (Array.isArray(frameRange)) {
+        if (frameRange.length !== 2) {
+            throw new TypeError('Frame range must be a tuple, got an array with length ' +
+                frameRange.length);
+        }
+        for (const value of frameRange) {
+            if (typeof value !== 'number') {
+                throw new Error(`Each value of frame range must be a number, but got ${typeof value} (${JSON.stringify(value)})`);
+            }
+            if (!Number.isFinite(value)) {
+                throw new TypeError('Each value of frame range must be finite, but got ' + value);
+            }
+            if (!Number.isInteger(value)) {
+                throw new Error(`Each value of frame range must be an integer, but got a float (${value})`);
+            }
+            if (value < 0) {
+                throw new Error(`Each value of frame range must be non-negative, but got ${value}`);
+            }
+        }
+        const [first, second] = frameRange;
+        if (second < first) {
+            throw new Error('The second value of frame range must be not smaller than the first one, but got ' +
+                frameRange.join('-'));
+        }
+        return;
+    }
+    throw new TypeError('Frame range must be a number or a tuple of numbers, but got object of type ' +
+        typeof frameRange);
+};
+exports.validateFrameRange = validateFrameRange;

package/package/dist/get-browser-instance.d.ts

@@ -0,0 +1,24 @@
+import type { BrowserExecutable } from './browser-executable';
+import type { BrowserLog } from './browser-log';
+import type { HeadlessBrowser } from './browser/Browser';
+import type { OnLog, Page } from './browser/BrowserPage';
+import type { LogLevel } from './log-level';
+import type { ChromiumOptions } from './open-browser';
+import type { ChromeMode } from './options/chrome-mode';
+import type { OnBrowserDownload } from './options/on-browser-download';
+export declare const getPageAndCleanupFn: ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, onBrowserLog, onLog, }: {
+    passedInInstance: HeadlessBrowser | undefined;
+    browserExecutable: BrowserExecutable | null;
+    chromiumOptions: ChromiumOptions;
+    indent: boolean;
+    forceDeviceScaleFactor: number | undefined;
+    logLevel: LogLevel;
+    onBrowserDownload: OnBrowserDownload;
+    chromeMode: ChromeMode;
+    pageIndex: number;
+    onBrowserLog: null | ((log: BrowserLog) => void);
+    onLog: OnLog;
+}) => Promise<{
+    cleanupPage: () => Promise<void>;
+    page: Page;
+}>;

package/package/dist/get-browser-instance.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageAndCleanupFn = void 0;
+const browser_1 = require("./browser");
+const logger_1 = require("./logger");
+const open_browser_1 = require("./open-browser");
+const getPageAndCleanupFn = async ({ passedInInstance, browserExecutable, chromiumOptions, forceDeviceScaleFactor, indent, logLevel, onBrowserDownload, chromeMode, pageIndex, onBrowserLog, onLog, }) => {
+    if (passedInInstance) {
+        const page = await passedInInstance.newPage({
+            context: () => null,
+            logLevel,
+            indent,
+            pageIndex,
+            onBrowserLog,
+            onLog,
+        });
+        return {
+            page,
+            cleanupPage: () => {
+                // Close puppeteer page and don't wait for it to finish.
+                // Keep browser open.
+                page.close().catch((err) => {
+                    if (!err.message.includes('Target closed')) {
+                        logger_1.Log.error({ indent, logLevel }, 'Was not able to close puppeteer page', err);
+                    }
+                });
+                return Promise.resolve();
+            },
+        };
+    }
+    const browserInstance = await (0, open_browser_1.internalOpenBrowser)({
+        browser: browser_1.DEFAULT_BROWSER,
+        browserExecutable,
+        chromiumOptions,
+        forceDeviceScaleFactor,
+        indent,
+        viewport: null,
+        logLevel,
+        onBrowserDownload,
+        chromeMode,
+    });
+    const browserPage = await browserInstance.newPage({
+        context: () => null,
+        logLevel,
+        indent,
+        pageIndex,
+        onBrowserLog,
+        onLog,
+    });
+    return {
+        page: browserPage,
+        cleanupPage: () => {
+            // Close whole browser that was just created and don't wait for it to finish.
+            browserInstance.close({ silent: true }).catch((err) => {
+                if (!err.message.includes('Target closed')) {
+                    logger_1.Log.error({ indent, logLevel }, 'Was not able to close puppeteer page', err);
+                }
+            });
+            return Promise.resolve();
+        },
+    };
+};
+exports.getPageAndCleanupFn = getPageAndCleanupFn;

package/package/dist/get-bundle-url-from-serve-url.d.ts

@@ -0,0 +1,2 @@
+export declare const getBundleUrlFromServeUrl: (serveUrl: string) => string;
+export declare const getBundleMapUrlFromServeUrl: (serveUrl: string) => string;

package/package/dist/get-bundle-url-from-serve-url.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBundleMapUrlFromServeUrl = exports.getBundleUrlFromServeUrl = void 0;
+const path_1 = __importDefault(require("path"));
+const no_react_1 = require("remotion/no-react");
+const is_serve_url_1 = require("./is-serve-url");
+const map = (webpackBundleOrServeUrl, suffix) => {
+    if ((0, is_serve_url_1.isServeUrl)(webpackBundleOrServeUrl)) {
+        const parsed = new URL(webpackBundleOrServeUrl);
+        const idx = parsed.pathname.lastIndexOf('/');
+        if (idx === -1) {
+            return parsed.origin + '/' + suffix;
+        }
+        return parsed.origin + parsed.pathname.substring(0, idx + 1) + suffix;
+    }
+    const index = webpackBundleOrServeUrl.lastIndexOf(path_1.default.sep);
+    const url = webpackBundleOrServeUrl.substring(0, index + 1) + suffix;
+    return url;
+};
+const getBundleUrlFromServeUrl = (serveUrl) => {
+    return map(serveUrl, no_react_1.NoReactInternals.bundleName);
+};
+exports.getBundleUrlFromServeUrl = getBundleUrlFromServeUrl;
+const getBundleMapUrlFromServeUrl = (serveUrl) => {
+    return map(serveUrl, no_react_1.NoReactInternals.bundleMapName);
+};
+exports.getBundleMapUrlFromServeUrl = getBundleMapUrlFromServeUrl;