@remotion/renderer 4.0.0-webhook.26 → 4.1.0-alpha1

package/dist/compositor/compositor.js

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCompositor = exports.startLongRunningCompositor = exports.getIdealMaximumFrameCacheItems = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const call_ffmpeg_1 = require("../call-ffmpeg");
+const get_concurrency_1 = require("../get-concurrency");
+const logger_1 = require("../logger");
+const compose_1 = require("./compose");
+const get_executable_path_1 = require("./get-executable-path");
+const make_nonce_1 = require("./make-nonce");
+const getIdealMaximumFrameCacheItems = () => {
+    const freeMemory = node_os_1.default.freemem();
+    // Assuming 1 frame is approximately 6MB
+    // Assuming only half the available memory should be used
+    const max = Math.floor(freeMemory / (1024 * 1024 * 6));
+    // Never store more than 1000 frames
+    // But 100 is needed even if it's going to swap
+    return Math.max(100, Math.min(max, 1000));
+};
+exports.getIdealMaximumFrameCacheItems = getIdealMaximumFrameCacheItems;
+const startLongRunningCompositor = (maximumFrameCacheItems, verbose, indent) => {
+    return (0, exports.startCompositor)('StartLongRunningProcess', {
+        concurrency: (0, get_concurrency_1.getActualConcurrency)(null),
+        maximum_frame_cache_items: maximumFrameCacheItems,
+        verbose,
+    }, indent);
+};
+exports.startLongRunningCompositor = startLongRunningCompositor;
+const startCompositor = (type, payload, indent) => {
+    var _a;
+    const bin = (0, get_executable_path_1.getExecutablePath)('compositor');
+    if (!process.env.READ_ONLY_FS) {
+        (0, node_fs_1.chmodSync)(bin, 0o755);
+    }
+    const fullCommand = (0, compose_1.serializeCommand)(type, payload);
+    const child = (0, node_child_process_1.spawn)(bin, [JSON.stringify(fullCommand)], (0, call_ffmpeg_1.dynamicLibraryPathOptions)());
+    const stderrChunks = [];
+    let outputBuffer = Buffer.from('');
+    const separator = Buffer.from('remotion_buffer:');
+    const waiters = new Map();
+    const onMessage = (statusType, nonce, data) => {
+        if (nonce === '0') {
+            logger_1.Log.verboseAdvanced({ indent, logLevel: (0, logger_1.getLogLevel)(), tag: 'compositor' }, data.toString('utf8'));
+        }
+        if (waiters.has(nonce)) {
+            if (statusType === 'error') {
+                try {
+                    const parsed = JSON.parse(data.toString('utf8'));
+                    waiters.get(nonce).reject(new Error(`Compositor error: ${parsed.error}\n${parsed.backtrace}`));
+                }
+                catch (err) {
+                    waiters.get(nonce).reject(new Error(data.toString('utf8')));
+                }
+            }
+            else {
+                waiters.get(nonce).resolve(data);
+            }
+            waiters.delete(nonce);
+        }
+    };
+    let runningStatus = { type: 'running' };
+    let missingData = null;
+    const processInput = () => {
+        let separatorIndex = outputBuffer.indexOf(separator);
+        if (separatorIndex === -1) {
+            return;
+        }
+        separatorIndex += separator.length;
+        let nonceString = '';
+        let lengthString = '';
+        let statusString = '';
+        // Each message from Rust is prefixed with `remotion_buffer;{[nonce]}:{[length]}`
+        // Let's read the buffer to extract the nonce, and if the full length is available,
+        // we'll extract the data and pass it to the callback.
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            // 0x3a is the character ":"
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            nonceString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                separatorIndex++;
+                break;
+            }
+            separatorIndex++;
+            lengthString += String.fromCharCode(nextDigit);
+        }
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const nextDigit = outputBuffer[separatorIndex];
+            if (nextDigit === 0x3a) {
+                break;
+            }
+            separatorIndex++;
+            statusString += String.fromCharCode(nextDigit);
+        }
+        const length = Number(lengthString);
+        const status = Number(statusString);
+        const dataLength = outputBuffer.length - separatorIndex - 1;
+        if (dataLength < length) {
+            missingData = {
+                dataMissing: length - dataLength,
+            };
+            return;
+        }
+        const data = outputBuffer.subarray(separatorIndex + 1, separatorIndex + 1 + Number(lengthString));
+        onMessage(status === 1 ? 'error' : 'success', nonceString, data);
+        missingData = null;
+        outputBuffer = outputBuffer.subarray(separatorIndex + Number(lengthString) + 1);
+        processInput();
+    };
+    let unprocessedBuffers = [];
+    child.stdout.on('data', (data) => {
+        unprocessedBuffers.push(data);
+        const separatorIndex = data.indexOf(separator);
+        if (separatorIndex === -1) {
+            if (missingData) {
+                missingData.dataMissing -= data.length;
+            }
+            if (!missingData || missingData.dataMissing > 0) {
+                return;
+            }
+        }
+        unprocessedBuffers.unshift(outputBuffer);
+        outputBuffer = Buffer.concat(unprocessedBuffers);
+        unprocessedBuffers = [];
+        processInput();
+    });
+    child.stderr.on('data', (data) => {
+        stderrChunks.push(data);
+    });
+    let resolve = null;
+    let reject = null;
+    child.on('close', (code) => {
+        const waitersToKill = Array.from(waiters.values());
+        if (code === 0) {
+            runningStatus = { type: 'quit-without-error' };
+            resolve === null || resolve === void 0 ? void 0 : resolve();
+            for (const waiter of waitersToKill) {
+                waiter.reject(new Error(`Compositor already quit`));
+            }
+            waiters.clear();
+        }
+        else {
+            const errorMessage = Buffer.concat(stderrChunks).toString('utf-8');
+            runningStatus = { type: 'quit-with-error', error: errorMessage };
+            const error = new Error(`Compositor panicked: ${errorMessage}`);
+            for (const waiter of waitersToKill) {
+                waiter.reject(error);
+            }
+            waiters.clear();
+            reject === null || reject === void 0 ? void 0 : reject(error);
+        }
+    });
+    return {
+        waitForDone: () => {
+            return new Promise((res, rej) => {
+                if (runningStatus.type === 'quit-without-error') {
+                    rej(new Error('Compositor already quit'));
+                    return;
+                }
+                if (runningStatus.type === 'quit-with-error') {
+                    rej(new Error(`Compositor already quit: ${runningStatus.error}`));
+                    return;
+                }
+                resolve = res;
+                reject = rej;
+            });
+        },
+        finishCommands: () => {
+            if (runningStatus.type === 'quit-with-error') {
+                throw new Error(`Compositor already quit: ${runningStatus.error}`);
+            }
+            if (runningStatus.type === 'quit-without-error') {
+                throw new Error('Compositor already quit');
+            }
+            child.stdin.write('EOF\n');
+        },
+        executeCommand: (command, params) => {
+            if (runningStatus.type === 'quit-without-error') {
+                throw new Error('Compositor already quit');
+            }
+            if (runningStatus.type === 'quit-with-error') {
+                throw new Error(`Compositor quit: ${runningStatus.error}`);
+            }
+            return new Promise((_resolve, _reject) => {
+                const nonce = (0, make_nonce_1.makeNonce)();
+                const composed = {
+                    nonce,
+                    payload: {
+                        type: command,
+                        params,
+                    },
+                };
+                // TODO: Should have a way to error out a single task
+                child.stdin.write(JSON.stringify(composed) + '\n');
+                waiters.set(nonce, {
+                    resolve: _resolve,
+                    reject: _reject,
+                });
+            });
+        },
+        pid: (_a = child.pid) !== null && _a !== void 0 ? _a : null,
+    };
+};
+exports.startCompositor = startCompositor;

package/dist/compositor/get-executable-path.d.ts

@@ -0,0 +1 @@
+export declare const getExecutablePath: (type: 'compositor' | 'ffmpeg' | 'ffprobe' | 'ffmpeg-cwd') => string;

package/dist/compositor/get-executable-path.js

@@ -0,0 +1,57 @@
+"use strict";
+// Adapted from @swc/core package
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExecutablePath = void 0;
+function isMusl() {
+    // @ts-expect-error no types
+    const { glibcVersionRuntime } = process.report.getReport().header;
+    return !glibcVersionRuntime;
+}
+const getExecutablePath = (type) => {
+    if (type === 'compositor' && process.env.COMPOSITOR_PATH) {
+        return process.env.COMPOSITOR_PATH;
+    }
+    const key = type === 'compositor'
+        ? 'binaryPath'
+        : type === 'ffmpeg'
+            ? 'ffmpegPath'
+            : type === 'ffprobe'
+                ? 'ffprobePath'
+                : 'ffmpegCwd';
+    switch (process.platform) {
+        case 'win32':
+            switch (process.arch) {
+                case 'x64':
+                    return require('@remotion/compositor-win32-x64-msvc')[key];
+                default:
+                    throw new Error(`Unsupported architecture on Windows: ${process.arch}`);
+            }
+        case 'darwin':
+            switch (process.arch) {
+                case 'x64':
+                    return require('@remotion/compositor-darwin-x64')[key];
+                case 'arm64':
+                    return require('@remotion/compositor-darwin-arm64')[key];
+                default:
+                    throw new Error(`Unsupported architecture on macOS: ${process.arch}`);
+            }
+        case 'linux':
+            switch (process.arch) {
+                case 'x64':
+                    if (isMusl()) {
+                        return require('@remotion/compositor-linux-x64-musl')[key];
+                    }
+                    return require('@remotion/compositor-linux-x64-gnu')[key];
+                case 'arm64':
+                    if (isMusl()) {
+                        return require('@remotion/compositor-linux-arm64-musl')[key];
+                    }
+                    return require('@remotion/compositor-linux-arm64-gnu')[key];
+                default:
+                    throw new Error(`Unsupported architecture on Linux: ${process.arch}`);
+            }
+        default:
+            throw new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`);
+    }
+};
+exports.getExecutablePath = getExecutablePath;

package/dist/compositor/make-nonce.d.ts

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

package/dist/compositor/make-nonce.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeNonce = void 0;
+const makeNonce = () => {
+    return (Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15));
+};
+exports.makeNonce = makeNonce;

package/dist/compositor/payloads.d.ts

@@ -0,0 +1,68 @@
+export type Layer = {
+    type: 'PngImage';
+    params: {
+        src: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'JpgImage';
+    params: {
+        src: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+} | {
+    type: 'Solid';
+    params: {
+        fill: [number, number, number, number];
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};
+export type CompositorImageFormat = 'Png' | 'Jpeg';
+export type CompositorCommand = {
+    Compose: {
+        output: string;
+        width: number;
+        height: number;
+        layers: Layer[];
+        output_format: CompositorImageFormat;
+    };
+    ExtractFrame: {
+        input: string;
+        time: number;
+        transparent: boolean;
+    };
+    Echo: {
+        message: string;
+    };
+    StartLongRunningProcess: {
+        concurrency: number;
+        maximum_frame_cache_items: number;
+        verbose: boolean;
+    };
+    GetOpenVideoStats: {};
+    DeliberatePanic: {};
+    CloseAllVideos: {};
+    FreeUpMemory: {
+        percent_of_memory: number;
+    };
+};
+export type CompositorCommandSerialized<T extends keyof CompositorCommand> = {
+    nonce: string;
+    payload: {
+        type: T;
+        params: CompositorCommand[T];
+    };
+};
+export type ErrorPayload = {
+    error: string;
+    backtrace: string;
+};

package/dist/create-ffmpeg-complex-filter.d.ts

@@ -1,5 +1,9 @@
 import type { DownloadMap } from './assets/download-map';
-export declare const createFfmpegComplexFilter: (filters: number, downloadMap: DownloadMap) => Promise<{
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const createFfmpegComplexFilter: ({ filters, downloadMap, }: {
+    filters: PreprocessedAudioTrack[];
+    downloadMap: DownloadMap;
+}) => Promise<{
     complexFilterFlag: [string, string] | null;
     cleanup: () => void;
 }>;

package/dist/create-ffmpeg-complex-filter.js

@@ -3,12 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFfmpegComplexFilter = void 0;
 const create_ffmpeg_merge_filter_1 = require("./create-ffmpeg-merge-filter");
 const ffmpeg_filter_file_1 = require("./ffmpeg-filter-file");
-const createFfmpegComplexFilter = async (filters, downloadMap) => {
-    if (filters === 0) {
+const createFfmpegComplexFilter = async ({ filters, downloadMap, }) => {
+    if (filters.length === 0) {
         return { complexFilterFlag: null, cleanup: () => undefined };
     }
-    const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)(filters);
-    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFile)(complexFilter, downloadMap);
+    const complexFilter = (0, create_ffmpeg_merge_filter_1.createFfmpegMergeFilter)({
+        inputs: filters,
+    });
+    const { file, cleanup } = await (0, ffmpeg_filter_file_1.makeFfmpegFilterFileStr)(complexFilter, downloadMap);
     return {
         complexFilterFlag: ['-filter_complex_script', file],
         cleanup,

package/dist/create-ffmpeg-merge-filter.d.ts

@@ -1 +1,5 @@
-export declare const createFfmpegMergeFilter: (inputs: number) => string;
+import type { PreprocessedAudioTrack } from './preprocess-audio-track';
+export declare const OUTPUT_FILTER_NAME = "outputaudio";
+export declare const createFfmpegMergeFilter: ({ inputs, }: {
+    inputs: PreprocessedAudioTrack[];
+}) => string;

package/dist/create-ffmpeg-merge-filter.js

@@ -1,18 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFfmpegMergeFilter = void 0;
+exports.createFfmpegMergeFilter = exports.OUTPUT_FILTER_NAME = void 0;
 const truthy_1 = require("./truthy");
-const createFfmpegMergeFilter = (inputs) => {
-    const leftChannel = new Array(inputs * 2)
-        .fill(true)
-        .map((_, i) => (i % 2 === 0 ? `c${i}` : null))
-        .filter(truthy_1.truthy)
-        .join('+');
-    const rightChannel = new Array(inputs * 2)
-        .fill(true)
-        .map((_, i) => (i % 2 === 1 ? `c${i}` : null))
-        .filter(truthy_1.truthy)
-        .join('+');
-    return `[0:a][1:a]amerge=inputs=${inputs},pan=stereo|c0=${leftChannel}|c1=${rightChannel}[a]`;
+exports.OUTPUT_FILTER_NAME = 'outputaudio';
+const createFfmpegMergeFilter = ({ inputs, }) => {
+    const pads = inputs.map((input, index) => {
+        const filters = [
+            input.filter.pad_start ? input.filter.pad_start : null,
+            input.filter.pad_end ? input.filter.pad_end : null,
+            'acopy',
+        ];
+        return `[${index}:a]${filters.filter(truthy_1.truthy).join(',')}[padded${index}]`;
+    });
+    const normalize = ':normalize=0';
+    return [
+        ...pads,
+        `${new Array(inputs.length)
+            .fill(true)
+            .map((_, i) => {
+            return `[padded${i}]`;
+        })
+            .join('')}amix=inputs=${inputs.length}:dropout_transition=0${normalize}[${exports.OUTPUT_FILTER_NAME}]`,
+    ].join(';');
 };
 exports.createFfmpegMergeFilter = createFfmpegMergeFilter;

package/dist/create-silent-audio.d.ts

@@ -1,6 +1,4 @@
-import type { FfmpegExecutable } from './ffmpeg-executable';
-export declare const createSilentAudio: ({ ffmpegExecutable, numberOfSeconds, outName, }: {
-    ffmpegExecutable: FfmpegExecutable;
+export declare const createSilentAudio: ({ numberOfSeconds, outName, }: {
     numberOfSeconds: number;
     outName: string;
 }) => Promise<void>;

package/dist/create-silent-audio.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSilentAudio = void 0;
-const execa_1 = __importDefault(require("execa"));
+const call_ffmpeg_1 = require("./call-ffmpeg");
 const sample_rate_1 = require("./sample-rate");
-const createSilentAudio = async ({ ffmpegExecutable, numberOfSeconds, outName, }) => {
-    await (0, execa_1.default)(ffmpegExecutable !== null && ffmpegExecutable !== void 0 ? ffmpegExecutable : 'ffmpeg', [
+const createSilentAudio = async ({ numberOfSeconds, outName, }) => {
+    await (0, call_ffmpeg_1.callFf)('ffmpeg', [
         '-f',
         'lavfi',
         '-i',

package/dist/crf.d.ts

@@ -1,5 +1,9 @@
 import type { Codec } from './codec';
-export declare type Crf = number | undefined;
+export type Crf = number | undefined;
 export declare const getDefaultCrfForCodec: (codec: Codec) => number;
 export declare const getValidCrfRanges: (codec: Codec) => [number, number];
-export declare const validateSelectedCrfAndCodecCombination: (crf: unknown, codec: Codec) => void;
+export declare const validateQualitySettings: ({ codec, crf, videoBitrate, }: {
+    crf: unknown;
+    codec: Codec;
+    videoBitrate: string | null | undefined;
+}) => string[];

package/dist/crf.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSelectedCrfAndCodecCombination = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
+exports.validateQualitySettings = exports.getValidCrfRanges = exports.getDefaultCrfForCodec = void 0;
 const is_audio_codec_1 = require("./is-audio-codec");
 const getDefaultCrfForCodec = (codec) => {
     if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
@@ -9,7 +9,7 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'h264' || codec === 'h264-mkv') {
         return 18; // FFMPEG default 23
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return 23; // FFMPEG default 28
     }
     if (codec === 'vp8') {
@@ -21,6 +21,9 @@ const getDefaultCrfForCodec = (codec) => {
     if (codec === 'prores') {
         return 0;
     }
+    if (codec === 'gif') {
+        return 0;
+    }
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getDefaultCrfForCodec = getDefaultCrfForCodec;
@@ -31,10 +34,13 @@ const getValidCrfRanges = (codec) => {
     if (codec === 'prores') {
         return [0, 0];
     }
+    if (codec === 'gif') {
+        return [0, 0];
+    }
     if (codec === 'h264' || codec === 'h264-mkv') {
         return [1, 51];
     }
-    if (codec === 'h265' || codec === 'gif') {
+    if (codec === 'h265') {
         return [0, 51];
     }
     if (codec === 'vp8') {
@@ -46,19 +52,46 @@ const getValidCrfRanges = (codec) => {
     throw new TypeError(`Got unexpected codec "${codec}"`);
 };
 exports.getValidCrfRanges = getValidCrfRanges;
-const validateSelectedCrfAndCodecCombination = (crf, codec) => {
-    if (crf === null) {
-        return;
+const validateQualitySettings = ({ codec, crf, videoBitrate, }) => {
+    if (crf && videoBitrate) {
+        throw new Error('"crf" and "videoBitrate" can not both be set. Choose one of either.');
+    }
+    if (videoBitrate) {
+        if (codec === 'prores') {
+            console.warn('ProRes does not support videoBitrate. Ignoring.');
+            return [];
+        }
+        if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+            console.warn(`${codec} does not support videoBitrate. Ignoring.`);
+            return [];
+        }
+        return ['-b:v', videoBitrate];
+    }
+    if (crf === null || typeof crf === 'undefined') {
+        const actualCrf = (0, exports.getDefaultCrfForCodec)(codec);
+        return ['-crf', String(actualCrf)];
     }
     if (typeof crf !== 'number') {
         throw new TypeError('Expected CRF to be a number, but is ' + JSON.stringify(crf));
     }
     const range = (0, exports.getValidCrfRanges)(codec);
     if (crf === 0 && (codec === 'h264' || codec === 'h264-mkv')) {
-        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably want. Set CRF to a higher value to fix this error.");
+        throw new TypeError("Setting the CRF to 0 with a H264 codec is not supported anymore because of it's inconsistencies between platforms. Videos with CRF 0 cannot be played on iOS/macOS. 0 is a extreme value with inefficient settings which you probably do not want. Set CRF to a higher value to fix this error.");
     }
     if (crf < range[0] || crf > range[1]) {
+        if (range[0] === 0 && range[1] === 0) {
+            throw new TypeError(`The "${codec}" codec does not support the --crf option.`);
+        }
         throw new TypeError(`CRF must be between ${range[0]} and ${range[1]} for codec ${codec}. Passed: ${crf}`);
     }
+    if (codec === 'prores') {
+        console.warn('ProRes does not support the "crf" option. Ignoring.');
+        return [];
+    }
+    if ((0, is_audio_codec_1.isAudioCodec)(codec)) {
+        console.warn(`${codec} does not support the "crf" option. Ignoring.`);
+        return [];
+    }
+    return ['-crf', String(crf)];
 };
-exports.validateSelectedCrfAndCodecCombination = validateSelectedCrfAndCodecCombination;
+exports.validateQualitySettings = validateQualitySettings;

package/dist/cycle-browser-tabs.d.ts

@@ -1,7 +1,4 @@
-import type { openBrowser } from './open-browser';
-declare type Await<T> = T extends PromiseLike<infer U> ? U : T;
-declare type Browser = Await<ReturnType<typeof openBrowser>>;
-export declare const cycleBrowserTabs: (puppeteerInstance: Browser, concurrency: number) => {
+import type { BrowserReplacer } from './replace-browser';
+export declare const cycleBrowserTabs: (puppeteerInstance: BrowserReplacer, concurrency: number) => {
     stopCycling: () => void;
 };
-export {};

package/dist/cycle-browser-tabs.js

@@ -13,24 +13,24 @@ const cycleBrowserTabs = (puppeteerInstance, concurrency) => {
     const set = () => {
         interval = setTimeout(() => {
             puppeteerInstance
+                .getBrowser()
                 .pages()
                 .then((pages) => {
-                var _a;
                 if (pages.length === 0) {
                     return;
                 }
                 const currentPage = pages[i % pages.length];
                 i++;
-                if (!((_a = currentPage === null || currentPage === void 0 ? void 0 : currentPage.isClosed) === null || _a === void 0 ? void 0 : _a.call(currentPage)) &&
+                if (!(currentPage === null || currentPage === void 0 ? void 0 : currentPage.closed) &&
                     !stopped &&
                     (currentPage === null || currentPage === void 0 ? void 0 : currentPage.url()) !== 'about:blank') {
                     return currentPage.bringToFront();
                 }
             })
-                .then(() => {
+                .catch((err) => console.log(err))
+                .finally(() => {
                 set();
-            })
-                .catch((err) => console.log(err));
+            });
         }, 200);
     };
     set();

package/dist/delete-directory.d.ts

@@ -1 +1 @@
-export declare const deleteDirectory: (directory: string) => Promise<void>;
+export declare const deleteDirectory: (directory: string) => void;