@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/browser/devtools-types.js

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

package/package/dist/browser/flaky-errors.d.ts

@@ -0,0 +1,2 @@
+export declare const isTargetClosedErr: (error: Error | undefined) => boolean | undefined;
+export declare const isFlakyNetworkError: (error: Error | undefined) => boolean | undefined;

package/package/dist/browser/flaky-errors.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFlakyNetworkError = exports.isTargetClosedErr = void 0;
+const isTargetClosedErr = (error) => {
+    var _a, _b;
+    return (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('Target closed')) ||
+        ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('Session closed')));
+};
+exports.isTargetClosedErr = isTargetClosedErr;
+const isFlakyNetworkError = (error) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('ERR_CONNECTION_REFUSED')) ||
+        ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('ERR_CONNECTION_RESET')) ||
+        ((_c = error === null || error === void 0 ? void 0 : error.message) === null || _c === void 0 ? void 0 : _c.includes('ERR_CONNECTION_TIMED_OUT')) ||
+        ((_d = error === null || error === void 0 ? void 0 : error.message) === null || _d === void 0 ? void 0 : _d.includes('ERR_INTERNET_DISCONNECTED')) ||
+        ((_e = error === null || error === void 0 ? void 0 : error.message) === null || _e === void 0 ? void 0 : _e.includes('ERR_NAME_RESOLUTION_FAILED')) ||
+        ((_f = error === null || error === void 0 ? void 0 : error.message) === null || _f === void 0 ? void 0 : _f.includes('ERR_ADDRESS_UNREACHABLE')) ||
+        ((_g = error === null || error === void 0 ? void 0 : error.message) === null || _g === void 0 ? void 0 : _g.includes('ERR_NETWORK_CHANGED')));
+};
+exports.isFlakyNetworkError = isFlakyNetworkError;

package/package/dist/browser/get-download-destination.d.ts

@@ -0,0 +1 @@
+export declare const getDownloadsCacheDir: () => string;

package/package/dist/browser/get-download-destination.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDownloadsCacheDir = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const getDownloadsCacheDir = () => {
+    const cwd = process.cwd();
+    let dir = cwd;
+    for (;;) {
+        try {
+            if (node_fs_1.default.statSync(node_path_1.default.join(dir, 'package.json')).isFile()) {
+                break;
+            }
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+        const parent = node_path_1.default.dirname(dir);
+        if (dir === parent) {
+            dir = undefined;
+            break;
+        }
+        dir = parent;
+    }
+    if (!dir) {
+        return node_path_1.default.resolve(cwd, '.remotion');
+    }
+    if (process.versions.pnp === '1') {
+        return node_path_1.default.resolve(dir, '.pnp/.remotion');
+    }
+    if (process.versions.pnp === '3') {
+        return node_path_1.default.resolve(dir, '.yarn/.remotion');
+    }
+    return node_path_1.default.resolve(dir, 'node_modules/.remotion');
+};
+exports.getDownloadsCacheDir = getDownloadsCacheDir;

package/package/dist/browser/handle-failed-resource.d.ts

@@ -0,0 +1,10 @@
+import type { LogLevel } from '../log-level';
+import type { HTTPRequest } from './HTTPRequest';
+import type { LoadingFailedEvent, ResponseReceivedExtraInfoEvent } from './devtools-types';
+export declare const handleFailedResource: ({ extraInfo, logLevel, indent, request, event, }: {
+    extraInfo: ResponseReceivedExtraInfoEvent[];
+    logLevel: LogLevel;
+    indent: boolean;
+    request: HTTPRequest;
+    event: LoadingFailedEvent;
+}) => void;

package/package/dist/browser/handle-failed-resource.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFailedResource = void 0;
+const logger_1 = require("../logger");
+const handleFailedResource = ({ extraInfo, logLevel, indent, request, event, }) => {
+    var _a, _b;
+    const firstExtraInfo = (_a = extraInfo[0]) !== null && _a !== void 0 ? _a : null;
+    logger_1.Log.warn({ indent, logLevel }, `Browser failed to load ${request._url} (${event.type}): ${event.errorText}`);
+    if (firstExtraInfo) {
+        logger_1.Log.warn({ indent, logLevel }, `HTTP status code: ${firstExtraInfo.statusCode}, headers:`);
+        logger_1.Log.warn({ indent, logLevel }, JSON.stringify(firstExtraInfo.headers, null, 2));
+    }
+    if (event.errorText === 'net::ERR_FAILED' &&
+        event.type === 'Fetch' &&
+        ((_b = request._url) === null || _b === void 0 ? void 0 : _b.includes('/proxy'))) {
+        logger_1.Log.warn({ indent, logLevel }, 'This could be caused by Chrome rejecting the request because the disk space is low.');
+        logger_1.Log.warn({ indent, logLevel }, 'This could be caused by Chrome rejecting the request because the disk space is low.');
+        logger_1.Log.warn({ indent, logLevel }, 'Consider increasing the disk size of your Lambda function.');
+    }
+};
+exports.handleFailedResource = handleFailedResource;

package/package/dist/browser/mitt/index.d.ts

@@ -0,0 +1,22 @@
+export type EventType = string | symbol;
+export type Handler<T = any> = (event?: T) => void;
+type WildcardHandler = (type: EventType, event?: any) => void;
+type EventHandlerList = Array<Handler>;
+type WildCardEventHandlerList = Array<WildcardHandler>;
+type EventHandlerMap = Map<EventType, EventHandlerList | WildCardEventHandlerList>;
+export interface Emitter {
+    all: EventHandlerMap;
+    on<T = any>(type: EventType, handler: Handler<T>): void;
+    on(type: '*', handler: WildcardHandler): void;
+    off<T = any>(type: EventType, handler: Handler<T>): void;
+    off(type: '*', handler: WildcardHandler): void;
+    emit<T = any>(type: EventType, event?: T): void;
+    emit(type: '*', event?: any): void;
+}
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+export default function mitt(all?: EventHandlerMap): Emitter;
+export {};

package/package/dist/browser/mitt/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mitt;
+/**
+ * Mitt: Tiny (~200b) functional event emitter / pubsub.
+ * @name mitt
+ * @returns {Mitt}
+ */
+function mitt(all) {
+    all = all || new Map();
+    return {
+        /**
+         * A Map of event names to registered handler functions.
+         */
+        all,
+        /**
+         * Register an event handler for the given type.
+         * @param {string|symbol} type Type of event to listen for, or `"*"` for all events
+         * @param {Function} handler Function to call in response to given event
+         * @memberOf mitt
+         */
+        on: (type, handler) => {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            const added = handlers === null || handlers === void 0 ? void 0 : handlers.push(handler);
+            if (!added) {
+                all === null || all === void 0 ? void 0 : all.set(type, [handler]);
+            }
+        },
+        off: (type, handler) => {
+            const handlers = all === null || all === void 0 ? void 0 : all.get(type);
+            if (handlers) {
+                // eslint-disable-next-line no-bitwise
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit: (type, evt) => {
+            ((all === null || all === void 0 ? void 0 : all.get(type)) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(evt);
+            });
+            ((all === null || all === void 0 ? void 0 : all.get('*')) || [])
+                .slice()
+                .forEach((handler) => {
+                handler(type, evt);
+            });
+        },
+    };
+}

package/package/dist/browser/should-log-message.d.ts

@@ -0,0 +1,24 @@
+export declare const shouldLogBrowserMessage: (message: string) => boolean;
+type ParsedBrowserLogMessage = {
+    day: number;
+    month: number;
+    hour: number;
+    minute: number;
+    seconds: number;
+    microseconds: number;
+    level: string;
+    location: string;
+    lineNumber: number;
+    message: string;
+};
+export declare const parseBrowserLogMessage: (input: string) => ParsedBrowserLogMessage | null;
+export declare const formatChromeMessage: (input: string) => {
+    output: string;
+    tag: string;
+} | null;
+type ChromeLogLocation = {
+    location: string;
+    lineNumber: number;
+};
+export declare const parseChromeLogLocation: (message: string) => ChromeLogLocation | null;
+export {};

package/package/dist/browser/should-log-message.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseChromeLogLocation = exports.formatChromeMessage = exports.parseBrowserLogMessage = exports.shouldLogBrowserMessage = void 0;
+const shouldLogBrowserMessage = (message) => {
+    // Not relevant for the user
+    if (message.startsWith('DevTools listening on')) {
+        return false;
+    }
+    // In Ubuntu GitHub Action
+    if (message.includes('Falling back to ALSA for audio output')) {
+        return false;
+    }
+    // In Ubuntu GitHub Action
+    if (message.includes('Floss manager not present, cannot set Floss enable/disable')) {
+        return false;
+    }
+    // Noisy but harmless warning
+    if (message.includes('Failed to send GpuControl.CreateCommandBuffer')) {
+        return false;
+    }
+    if (message.includes('CreatePlatformSocket() failed: Address family not supported by protocol')) {
+        return false;
+    }
+    if (message.includes('Fontconfig error: No writable cache directories')) {
+        return false;
+    }
+    if (message.includes('AttributionReportingCrossAppWeb cannot be enabled in this configuration')) {
+        return false;
+    }
+    if (message.includes('Trying to Produce a Memory representation from a non-existent mailbox.')) {
+        return false;
+    }
+    if (message.includes('Received HEADERS for invalid stream')) {
+        return false;
+    }
+    if (message.includes('CVDisplayLinkCreateWithCGDisplay failed')) {
+        return false;
+    }
+    if (message.includes('Falling back to ALSA for audio output')) {
+        return false;
+    }
+    if (message.includes('VizNullHypothesis is disabled')) {
+        return false;
+    }
+    return true;
+};
+exports.shouldLogBrowserMessage = shouldLogBrowserMessage;
+const parseBrowserLogMessage = (input) => {
+    const format = /^\[([0-9]{4})\/([0-9]{6})\.([0-9]{6}):([A-Z]+):(.*)\(([0-9]+)\)\](.*)/;
+    const match = input.match(format);
+    if (!match) {
+        return null;
+    }
+    const date = match[1];
+    const day = parseInt(date.slice(0, 2), 10);
+    const month = parseInt(date.slice(2, 4), 10);
+    const time = match[2];
+    const hour = parseInt(time.slice(0, 2), 10);
+    const minute = parseInt(time.slice(2, 4), 10);
+    const seconds = parseInt(time.slice(4, 6), 10);
+    const microseconds = parseInt(match[3], 10);
+    const level = match[4];
+    const location = match[5];
+    const lineNumber = parseInt(match[6], 10);
+    const message = match[7].trim();
+    return {
+        day,
+        month,
+        hour,
+        minute,
+        seconds,
+        microseconds,
+        level,
+        location,
+        lineNumber,
+        message,
+    };
+};
+exports.parseBrowserLogMessage = parseBrowserLogMessage;
+const formatChromeMessage = (input) => {
+    const parsed = (0, exports.parseBrowserLogMessage)(input);
+    if (!parsed) {
+        return { output: input, tag: 'chrome' };
+    }
+    const { location, lineNumber, message } = parsed;
+    // Don't print console.log's, these are handled through the WebSocket
+    if (location === 'CONSOLE') {
+        return null;
+    }
+    return { output: `${location}:${lineNumber}: ${message}`, tag: 'chrome' };
+};
+exports.formatChromeMessage = formatChromeMessage;
+const parseChromeLogLocation = (message) => {
+    const regex = /(.*), source: (.*) \(([0-9]+)\)/;
+    const match = message.match(regex);
+    if (!match) {
+        return null;
+    }
+    return {
+        lineNumber: parseInt(match[3], 10),
+        location: match[2],
+    };
+};
+exports.parseChromeLogLocation = parseChromeLogLocation;

package/package/dist/browser/source-map-getter.d.ts

@@ -0,0 +1,2 @@
+import type { AnySourceMapConsumer } from '../symbolicate-stacktrace';
+export type SourceMapGetter = () => AnySourceMapConsumer | null;

package/package/dist/browser/source-map-getter.js

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

package/package/dist/browser/util.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { HeadlessBrowser } from './Browser';
+import type { CDPSession } from './Connection';
+import type { DevtoolsRemoteObject, ExceptionDetails } from './devtools-types';
+import type { CommonEventEmitter } from './EventEmitter';
+export declare function getExceptionMessage(exceptionDetails: ExceptionDetails): string;
+export declare function valueFromRemoteObject(remoteObject: DevtoolsRemoteObject): any;
+export declare function releaseObject(client: CDPSession, remoteObject: DevtoolsRemoteObject): Promise<void>;
+export declare function addEventListener(emitter: CommonEventEmitter, eventName: string | symbol, handler: (...args: any[]) => void): () => CommonEventEmitter;
+export declare function removeEventListeners(listeners: Array<() => void>): void;
+export declare const isString: (obj: unknown) => obj is string;
+export declare function evaluationString(fun: Function | string, ...args: unknown[]): string;
+export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
+export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
+export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number, browser: HeadlessBrowser): Promise<T>;
+interface ErrorLike extends Error {
+    name: string;
+    message: string;
+}
+export declare function isErrorLike(obj: unknown): obj is ErrorLike;
+export declare function isErrnoException(obj: unknown): obj is NodeJS.ErrnoException;
+export {};

package/package/dist/browser/util.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = void 0;
+exports.getExceptionMessage = getExceptionMessage;
+exports.valueFromRemoteObject = valueFromRemoteObject;
+exports.releaseObject = releaseObject;
+exports.addEventListener = addEventListener;
+exports.removeEventListeners = removeEventListeners;
+exports.evaluationString = evaluationString;
+exports.pageBindingDeliverResultString = pageBindingDeliverResultString;
+exports.pageBindingDeliverErrorString = pageBindingDeliverErrorString;
+exports.pageBindingDeliverErrorValueString = pageBindingDeliverErrorValueString;
+exports.waitWithTimeout = waitWithTimeout;
+exports.isErrorLike = isErrorLike;
+exports.isErrnoException = isErrnoException;
+const assert_1 = require("./assert");
+const Errors_1 = require("./Errors");
+function getExceptionMessage(exceptionDetails) {
+    if (exceptionDetails.exception) {
+        return (exceptionDetails.exception.description || exceptionDetails.exception.value);
+    }
+    let message = exceptionDetails.text;
+    if (exceptionDetails.stackTrace) {
+        for (const callframe of exceptionDetails.stackTrace.callFrames) {
+            const location = callframe.url +
+                ':' +
+                callframe.lineNumber +
+                ':' +
+                callframe.columnNumber;
+            const functionName = callframe.functionName || '<anonymous>';
+            message += `\n    at ${functionName} (${location})`;
+        }
+    }
+    return message;
+}
+function valueFromRemoteObject(remoteObject) {
+    (0, assert_1.assert)(!remoteObject.objectId, 'Cannot extract value when objectId is given');
+    if (remoteObject.unserializableValue) {
+        if (remoteObject.type === 'bigint' && typeof BigInt !== 'undefined') {
+            return BigInt(remoteObject.unserializableValue.replace('n', ''));
+        }
+        switch (remoteObject.unserializableValue) {
+            case '-0':
+                return -0;
+            case 'NaN':
+                return NaN;
+            case 'Infinity':
+                return Infinity;
+            case '-Infinity':
+                return -Infinity;
+            default:
+                throw new Error('Unsupported unserializable value: ' +
+                    remoteObject.unserializableValue);
+        }
+    }
+    return remoteObject.value;
+}
+async function releaseObject(client, remoteObject) {
+    if (!remoteObject.objectId) {
+        return;
+    }
+    await client
+        .send('Runtime.releaseObject', { objectId: remoteObject.objectId })
+        .catch(() => {
+        // Exceptions might happen in case of a page been navigated or closed.
+        // Swallow these since they are harmless and we don't leak anything in this case.
+    });
+}
+function addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return () => emitter.off(eventName, handler);
+}
+function removeEventListeners(listeners) {
+    for (const listener of listeners) {
+        listener();
+    }
+    listeners.length = 0;
+}
+const isString = (obj) => {
+    return typeof obj === 'string' || obj instanceof String;
+};
+exports.isString = isString;
+function evaluationString(fun, ...args) {
+    if ((0, exports.isString)(fun)) {
+        (0, assert_1.assert)(args.length === 0, 'Cannot evaluate a string with arguments');
+        return fun;
+    }
+    function serializeArgument(arg) {
+        if (Object.is(arg, undefined)) {
+            return 'undefined';
+        }
+        return JSON.stringify(arg);
+    }
+    return `(${fun})(${args.map(serializeArgument).join(',')})`;
+}
+function pageBindingDeliverResultString(name, seq, result) {
+    function deliverResult(_name, _seq, _result) {
+        window[_name].callbacks.get(_seq).resolve(_result);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverResult, name, seq, result);
+}
+function pageBindingDeliverErrorString(name, seq, message, stack) {
+    function deliverError(_name, _seq, _message, _stack) {
+        const error = new Error(_message);
+        error.stack = _stack;
+        window[_name].callbacks.get(_seq).reject(error);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverError, name, seq, message, stack);
+}
+function pageBindingDeliverErrorValueString(name, seq, value) {
+    function deliverErrorValue(_name, _seq, _value) {
+        window[_name].callbacks.get(_seq).reject(_value);
+        window[_name].callbacks.delete(_seq);
+    }
+    return evaluationString(deliverErrorValue, name, seq, value);
+}
+async function waitWithTimeout(promise, taskName, timeout, browser) {
+    let reject;
+    const timeoutError = new Errors_1.TimeoutError(`waiting for ${taskName} failed: timeout ${timeout}ms exceeded`);
+    const timeoutPromise = new Promise((_res, rej) => {
+        reject = rej;
+    });
+    let timeoutTimer = null;
+    if (timeout) {
+        timeoutTimer = setTimeout(() => {
+            return reject(timeoutError);
+        }, timeout);
+    }
+    try {
+        return await Promise.race([
+            new Promise((_, rej) => {
+                browser.once("closed" /* BrowserEmittedEvents.Closed */, () => {
+                    return rej();
+                });
+            }),
+            promise,
+            timeoutPromise,
+        ]);
+    }
+    finally {
+        if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+        }
+    }
+}
+function isErrorLike(obj) {
+    return (typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj);
+}
+function isErrnoException(obj) {
+    return (isErrorLike(obj) &&
+        ('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj));
+}

package/package/dist/browser-executable.d.ts

@@ -0,0 +1 @@
+export type BrowserExecutable = string | null;

package/package/dist/browser-executable.js

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

package/package/dist/browser-log.d.ts

@@ -0,0 +1,6 @@
+import type { ConsoleMessageLocation, ConsoleMessageType } from './browser/ConsoleMessage';
+export type BrowserLog = {
+    text: string;
+    stackTrace: ConsoleMessageLocation[];
+    type: ConsoleMessageType;
+};

package/package/dist/browser-log.js

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

package/package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export type Browser = 'chrome';
+export declare const DEFAULT_BROWSER: Browser;

package/package/dist/browser.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BROWSER = void 0;
+exports.DEFAULT_BROWSER = 'chrome';

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

@@ -0,0 +1,22 @@
+import execa from 'execa';
+import type { SpawnOptionsWithoutStdio } from 'node:child_process';
+import type { LogLevel } from './log-level';
+import type { CancelSignal } from './make-cancel-signal';
+export declare const callFf: ({ args, bin, indent, logLevel, options, binariesDirectory, cancelSignal, }: {
+    bin: "ffmpeg" | "ffprobe";
+    args: (string | null)[];
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    options?: execa.Options<string>;
+}) => execa.ExecaChildProcess<string>;
+export declare const callFfNative: ({ args, bin, indent, logLevel, options, binariesDirectory, cancelSignal, }: {
+    bin: "ffmpeg" | "ffprobe";
+    args: (string | null)[];
+    indent: boolean;
+    logLevel: LogLevel;
+    binariesDirectory: string | null;
+    cancelSignal: CancelSignal | undefined;
+    options?: SpawnOptionsWithoutStdio;
+}) => import("child_process").ChildProcessWithoutNullStreams;

package/package/dist/call-ffmpeg.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callFfNative = exports.callFf = void 0;
+const execa_1 = __importDefault(require("execa"));
+const node_child_process_1 = require("node:child_process");
+const path_1 = __importDefault(require("path"));
+const get_executable_path_1 = require("./compositor/get-executable-path");
+const get_explicit_env_1 = require("./compositor/get-explicit-env");
+const make_file_executable_1 = require("./compositor/make-file-executable");
+const truthy_1 = require("./truthy");
+const callFf = ({ args, bin, indent, logLevel, options, binariesDirectory, cancelSignal, }) => {
+    const executablePath = (0, get_executable_path_1.getExecutablePath)({
+        type: bin,
+        indent,
+        logLevel,
+        binariesDirectory,
+    });
+    (0, make_file_executable_1.makeFileExecutableIfItIsNot)(executablePath);
+    const cwd = path_1.default.dirname(executablePath);
+    const task = (0, execa_1.default)(executablePath, args.filter(truthy_1.truthy), {
+        cwd,
+        env: (0, get_explicit_env_1.getExplicitEnv)(cwd),
+        ...options,
+    });
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        task.kill();
+    });
+    return task;
+};
+exports.callFf = callFf;
+const callFfNative = ({ args, bin, indent, logLevel, options, binariesDirectory, cancelSignal, }) => {
+    const executablePath = (0, get_executable_path_1.getExecutablePath)({
+        type: bin,
+        indent,
+        logLevel,
+        binariesDirectory,
+    });
+    (0, make_file_executable_1.makeFileExecutableIfItIsNot)(executablePath);
+    const cwd = path_1.default.dirname(executablePath);
+    const task = (0, node_child_process_1.spawn)(executablePath, args.filter(truthy_1.truthy), {
+        cwd,
+        env: (0, get_explicit_env_1.getExplicitEnv)(cwd),
+        ...options,
+    });
+    cancelSignal === null || cancelSignal === void 0 ? void 0 : cancelSignal(() => {
+        task.kill();
+    });
+    return task;
+};
+exports.callFfNative = callFfNative;

package/package/dist/can-concat-seamlessly.d.ts

@@ -0,0 +1,4 @@
+import type { Codec } from './codec';
+import type { AudioCodec } from './options/audio-codec';
+export declare const canConcatAudioSeamlessly: (audioCodec: AudioCodec | null, chunkDurationInFrames: number) => boolean;
+export declare const canConcatVideoSeamlessly: (codec: Codec) => codec is "h264";

package/package/dist/can-concat-seamlessly.js

@@ -0,0 +1,17 @@
+"use strict";
+// Cannot do WAV yet, because currently assumes AAC in+outpoint
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canConcatVideoSeamlessly = exports.canConcatAudioSeamlessly = void 0;
+const canConcatAudioSeamlessly = (audioCodec, chunkDurationInFrames) => {
+    // Rendering a chunk that is too small generates too much overhead
+    // and is currently buggy
+    if (chunkDurationInFrames <= 4) {
+        return false;
+    }
+    return audioCodec === 'aac';
+};
+exports.canConcatAudioSeamlessly = canConcatAudioSeamlessly;
+const canConcatVideoSeamlessly = (codec) => {
+    return codec === 'h264';
+};
+exports.canConcatVideoSeamlessly = canConcatVideoSeamlessly;

package/package/dist/can-use-parallel-encoding.d.ts

@@ -0,0 +1,3 @@
+import type { Codec } from './codec';
+export declare const canUseParallelEncoding: (codec: Codec) => boolean;
+export declare const getShouldUsePartitionedRendering: () => boolean;