@remotion/cli 4.0.0-alpha.4 → 4.0.0-alpha5

package/LICENSE.md

@@ -1,34 +1,34 @@
 # Remotion License
 
-Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion create videos for free (even commercial), while a company license is required for for-profit organisations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
+Depending on the type of your legal entity, you are granted permission to use Remotion for your project. Individuals and small companies are allowed to use Remotion to create videos for free (even commercial), while a company license is required for for-profit organizations of a certain size. This two-tier system was designed to ensure funding for this project while still allowing the source code to be available and the program to be free for most. Read below for the exact terms of use.
 
 - [Free license](#free-license)
 - [Company license](#company-license)
 
 ## Free license
 
-Copyright © 2022 [Jonny Burger](https://jonny.io)
+Copyright © 2023 [Remotion](https://www.remotion.dev/)
 
 ### Eligibility
 
 You are eligible to use Remotion for free if you are:
 
 - an individual
-- a for-profit organisation with up to 3 employees
-- a non-profit or not-for-profit organisation
+- a for-profit organization with up to 3 employees
+- a non-profit or not-for-profit organization
 - evaluating whether Remotion is a good fit, and are not yet using it in a commercial way
 
 ### Allowed use cases
 
-Permission is hereby granted, free of charge, to any person eligible for the "Free license", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify and the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
+Permission is hereby granted, free of charge, to any person eligible for the "Free license", to use the software non-commercially or commercially for the purpose of creating videos and images and to modify the software to their own liking, for the purpose of fulfilling their custom use case or to contribute bug fixes or improvements back to Remotion.
 
 ### Disallowed use cases
 
-It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, sublicensing your own derivate of Remotion.
+It is not allowed to copy or modify Remotion code for the purpose of selling, renting, licensing, relicensing, or sublicensing your own derivate of Remotion.
 
 ### Warranty notice
 
-The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
+The software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the author or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
 
 ### Support
 
@@ -36,6 +36,6 @@ Support is provided on a best-we-can-do basis via GitHub Issues and Discord.
 
 ## Company license
 
-You are required to obtain a company license to use Remotion if you are not within the group of entities eligible for a free license. This license will enable you to use Remotion for the allowed use cases specified in the free license, and give you access to prioritized support.
+You are required to obtain a company license to use Remotion if you are not within the group of entities eligible for a free license. This license will enable you to use Remotion for the allowed use cases specified in the free license, and give you access to prioritized support (read the [Support Policy](/docs/support)).
 
 Visit [companies.remotion.dev](https://companies.remotion.dev) for pricing and to buy a license.

package/dist/ansi/ansi-diff.d.ts

@@ -11,9 +11,10 @@ export declare class AnsiDiff {
     _buffer: string | null;
     _out: Buffer[];
     _lines: Line[];
+    finished: boolean;
     constructor(opts?: Options);
-    resize: (opts: Options) => void;
     toString(): string | null;
+    finish(): Buffer;
     update(buffer: string | Buffer, opts?: {
         moveTo?: [number, number];
     }): Buffer;

package/dist/ansi/ansi-diff.js

@@ -6,26 +6,6 @@ const CLEAR_LINE = Buffer.from([0x1b, 0x5b, 0x30, 0x4b]);
 const NEWLINE = Buffer.from('\n');
 class AnsiDiff {
     constructor(opts) {
-        this.resize = (opts) => {
-            if (!opts)
-                opts = {};
-            if (opts.width)
-                this.width = opts.width;
-            if (opts.height)
-                this.height = opts.height;
-            if (this._buffer)
-                this.update(this._buffer);
-            const last = top(this._lines);
-            // eslint-disable-next-line no-negated-condition
-            if (!last) {
-                this.x = 0;
-                this.y = 0;
-            }
-            else {
-                this.x = last.remainder;
-                this.y = last.y + last.height;
-            }
-        };
         this._push = (buf) => {
             this._out.push(buf);
         };
@@ -36,11 +16,25 @@ class AnsiDiff {
         this._buffer = null;
         this._out = [];
         this._lines = [];
+        this.finished = false;
     }
     toString() {
         return this._buffer;
     }
+    finish() {
+        this.finished = true;
+        if (this._out.length === 0) {
+            return Buffer.from('');
+        }
+        if (!this._out[this._out.length - 1].toString().endsWith('\n')) {
+            return NEWLINE;
+        }
+        return Buffer.from('');
+    }
     update(buffer, opts) {
+        if (this.finished) {
+            return Buffer.from('');
+        }
         this._buffer = Buffer.isBuffer(buffer) ? buffer.toString() : buffer;
         const other = this._buffer;
         const oldLines = this._lines;

package/dist/ansi/ansi-split.d.ts

@@ -1 +1,2 @@
 export declare function splitAnsi(str: string): string[];
+export declare const stripAnsi: (str: string) => string;

package/dist/ansi/ansi-split.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitAnsi = void 0;
-const ansi_regex_1 = require("./ansi-regex");
+exports.stripAnsi = exports.splitAnsi = void 0;
+const ansiRegex = () => {
+    const pattern = [
+        '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+        '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+    ].join('|');
+    return new RegExp(pattern, 'g');
+};
 function splitAnsi(str) {
-    const parts = str.match((0, ansi_regex_1.ansiRegex)());
+    const parts = str.match(ansiRegex());
     if (!parts)
         return [str];
     const result = [];
@@ -29,3 +35,10 @@ function splitAnsi(str) {
     return result;
 }
 exports.splitAnsi = splitAnsi;
+const stripAnsi = (str) => {
+    if (typeof str !== 'string') {
+        throw new TypeError(`Expected a \`string\`, got \`${typeof str}\``);
+    }
+    return str.replace(ansiRegex(), '');
+};
+exports.stripAnsi = stripAnsi;

package/dist/benchmark.d.ts

@@ -0,0 +1 @@
+export declare const benchmarkCommand: (remotionRoot: string, args: string[]) => Promise<void>;

package/dist/benchmark.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkCommand = void 0;
+const renderer_1 = require("@remotion/renderer");
+const chalk_1 = require("./chalk");
+const cleanup_before_quit_1 = require("./cleanup-before-quit");
+const config_1 = require("./config");
+const convert_entry_point_to_serve_url_1 = require("./convert-entry-point-to-serve-url");
+const entry_point_1 = require("./entry-point");
+const get_cli_options_1 = require("./get-cli-options");
+const get_final_output_codec_1 = require("./get-final-output-codec");
+const image_formats_1 = require("./image-formats");
+const log_1 = require("./log");
+const make_progress_bar_1 = require("./make-progress-bar");
+const parse_command_line_1 = require("./parse-command-line");
+const progress_bar_1 = require("./progress-bar");
+const select_composition_1 = require("./select-composition");
+const setup_cache_1 = require("./setup-cache");
+const truthy_1 = require("./truthy");
+const DEFAULT_RUNS = 3;
+const getValidConcurrency = (cliConcurrency) => {
+    const { concurrencies } = parse_command_line_1.parsedCli;
+    if (!concurrencies) {
+        return [renderer_1.RenderInternals.getActualConcurrency(cliConcurrency)];
+    }
+    return concurrencies
+        .split(',')
+        .map((c) => parseInt(c.trim(), 10));
+};
+const runBenchmark = async (runs, options, onProgress) => {
+    const timeTaken = [];
+    for (let run = 0; run < runs; ++run) {
+        const startTime = performance.now();
+        await (0, renderer_1.renderMedia)({
+            ...options,
+            onProgress: ({ progress }) => onProgress === null || onProgress === void 0 ? void 0 : onProgress(run, progress),
+        });
+        const endTime = performance.now();
+        timeTaken.push(endTime - startTime);
+    }
+    return timeTaken;
+};
+const formatTime = (time) => {
+    let ret = '';
+    const hours = Math.floor(time / (60 * 60 * 1000));
+    if (hours) {
+        ret = `${hours}h`;
+    }
+    time %= 60 * 60 * 1000;
+    const minutes = Math.floor(time / (60 * 1000));
+    if (minutes) {
+        ret = `${ret}${minutes}m`;
+    }
+    time %= 60 * 1000;
+    const seconds = (time / 1000).toFixed(5);
+    if (seconds) {
+        ret = `${ret}${seconds}s`;
+    }
+    return ret;
+};
+const avg = (time) => time.reduce((prev, curr) => prev + curr) / time.length;
+const stdDev = (time) => {
+    const mean = avg(time);
+    return Math.sqrt(time.map((x) => (x - mean) ** 2).reduce((a, b) => a + b) / time.length);
+};
+const getResults = (results, runs) => {
+    const mean = avg(results);
+    const dev = stdDev(results);
+    const max = Math.max(...results);
+    const min = Math.min(...results);
+    return `    Time (${chalk_1.chalk.green('mean')} ± ${chalk_1.chalk.green('σ')}):         ${chalk_1.chalk.green(formatTime(mean))} ± ${chalk_1.chalk.green(formatTime(dev))}\n    Range (${chalk_1.chalk.blue('min')} ... ${chalk_1.chalk.red('max')}):     ${chalk_1.chalk.blue(formatTime(min))} ... ${chalk_1.chalk.red(formatTime(max))} \t ${chalk_1.chalk.gray(`${runs} runs`)}
+	`;
+};
+const makeBenchmarkProgressBar = ({ totalRuns, run, progress, doneIn, }) => {
+    const totalProgress = (run + progress) / totalRuns;
+    return [
+        `Rendering (${run + 1} out of ${totalRuns} runs)`,
+        (0, make_progress_bar_1.makeProgressBar)(totalProgress),
+        doneIn === null
+            ? `${(totalProgress * 100).toFixed(2)}% `
+            : chalk_1.chalk.gray(doneIn),
+    ].join(' ');
+};
+const benchmarkCommand = async (remotionRoot, args) => {
+    var _a, _b;
+    const runs = (_a = parse_command_line_1.parsedCli.runs) !== null && _a !== void 0 ? _a : DEFAULT_RUNS;
+    const { file, reason, remainingArgs } = (0, entry_point_1.findEntryPoint)(args, remotionRoot);
+    if (!file) {
+        log_1.Log.error('No entry file passed.');
+        log_1.Log.info('Pass an additional argument specifying the entry file');
+        log_1.Log.info();
+        log_1.Log.info(`$ remotion benchmark <entry file>`);
+        process.exit(1);
+    }
+    const fullEntryPoint = (0, convert_entry_point_to_serve_url_1.convertEntryPointToServeUrl)(file);
+    const { inputProps, envVariables, browserExecutable, chromiumOptions, port, puppeteerTimeout, browser, scale, publicDir, } = await (0, get_cli_options_1.getCliOptions)({
+        isLambda: false,
+        type: 'series',
+        remotionRoot,
+    });
+    log_1.Log.verbose('Entry point:', fullEntryPoint, 'reason:', reason);
+    const browserInstance = (0, renderer_1.openBrowser)(browser, {
+        browserExecutable,
+        shouldDumpIo: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+        chromiumOptions,
+        forceDeviceScaleFactor: scale,
+    });
+    const { urlOrBundle: bundleLocation, cleanup: cleanupBundle } = await (0, setup_cache_1.bundleOnCliOrTakeServeUrl)({
+        fullPath: fullEntryPoint,
+        publicDir,
+        remotionRoot,
+        onProgress: () => undefined,
+        indentOutput: false,
+        logLevel: config_1.ConfigInternals.Logging.getLogLevel(),
+        bundlingStep: 0,
+        steps: 1,
+        onDirectoryCreated: (dir) => {
+            (0, cleanup_before_quit_1.registerCleanupJob)(() => renderer_1.RenderInternals.deleteDirectory(dir));
+        },
+    });
+    (0, cleanup_before_quit_1.registerCleanupJob)(() => cleanupBundle());
+    const puppeteerInstance = await browserInstance;
+    const comps = await (0, renderer_1.getCompositions)(bundleLocation, {
+        inputProps,
+        envVariables,
+        chromiumOptions,
+        timeoutInMilliseconds: puppeteerTimeout,
+        port,
+        puppeteerInstance,
+    });
+    const ids = (remainingArgs[0]
+        ? remainingArgs[0]
+            .split(',')
+            .map((c) => c.trim())
+            .filter(truthy_1.truthy)
+        : await (0, select_composition_1.selectCompositions)(comps));
+    const compositions = ids.map((compId) => {
+        const composition = comps.find((c) => c.id === compId);
+        if (!composition) {
+            throw new Error(`No composition with the ID "${compId}" found.`);
+        }
+        return composition;
+    });
+    if (compositions.length === 0) {
+        log_1.Log.error('No composition IDs passed. Add another argument to the command specifying at least 1 composition ID.');
+    }
+    const benchmark = {};
+    let count = 1;
+    const { codec, reason: codecReason } = (0, get_final_output_codec_1.getFinalOutputCodec)({
+        cliFlag: parse_command_line_1.parsedCli.codec,
+        downloadName: null,
+        outName: null,
+        configFile: (_b = config_1.ConfigInternals.getOutputCodecOrUndefined()) !== null && _b !== void 0 ? _b : null,
+        uiCodec: null,
+    });
+    for (const composition of compositions) {
+        const { proResProfile, frameRange: defaultFrameRange, overwrite, jpegQuality, crf: configFileCrf, pixelFormat, scale: configFileScale, numberOfGifLoops, everyNthFrame, muted, enforceAudioTrack, ffmpegOverride, audioBitrate, videoBitrate, height, width, concurrency: unparsedConcurrency, } = await (0, get_cli_options_1.getCliOptions)({
+            isLambda: false,
+            type: 'series',
+            remotionRoot,
+        });
+        const concurrency = getValidConcurrency(unparsedConcurrency);
+        benchmark[composition.id] = {};
+        for (const con of concurrency) {
+            const benchmarkProgress = (0, progress_bar_1.createOverwriteableCliOutput)({
+                quiet: (0, parse_command_line_1.quietFlagProvided)(),
+                cancelSignal: null,
+            });
+            log_1.Log.info();
+            log_1.Log.info(`${chalk_1.chalk.bold(`Benchmark #${count++}:`)} ${chalk_1.chalk.gray(`composition=${composition.id} concurrency=${con} codec=${codec} (${codecReason})`)}`);
+            const timeTaken = await runBenchmark(runs, {
+                outputLocation: undefined,
+                composition: {
+                    ...composition,
+                    width: width !== null && width !== void 0 ? width : composition.width,
+                    height: height !== null && height !== void 0 ? height : composition.height,
+                },
+                crf: configFileCrf,
+                envVariables,
+                frameRange: defaultFrameRange,
+                imageFormat: (0, image_formats_1.getVideoImageFormat)({
+                    codec,
+                    uiImageFormat: null,
+                }),
+                inputProps,
+                overwrite,
+                pixelFormat,
+                proResProfile,
+                jpegQuality,
+                dumpBrowserLogs: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+                chromiumOptions,
+                timeoutInMilliseconds: config_1.ConfigInternals.getCurrentPuppeteerTimeout(),
+                scale: configFileScale,
+                port,
+                numberOfGifLoops,
+                everyNthFrame,
+                verbose: renderer_1.RenderInternals.isEqualOrBelowLogLevel(config_1.ConfigInternals.Logging.getLogLevel(), 'verbose'),
+                muted,
+                enforceAudioTrack,
+                browserExecutable,
+                ffmpegOverride,
+                serveUrl: bundleLocation,
+                codec,
+                audioBitrate,
+                videoBitrate,
+                puppeteerInstance,
+                concurrency: con,
+            }, (run, progress) => {
+                benchmarkProgress.update(makeBenchmarkProgressBar({
+                    totalRuns: runs,
+                    run,
+                    doneIn: null,
+                    progress,
+                }));
+            });
+            benchmarkProgress.update('');
+            benchmarkProgress.update(getResults(timeTaken, runs));
+            benchmark[composition.id][`${con}`] = timeTaken;
+        }
+    }
+    log_1.Log.info();
+};
+exports.benchmarkCommand = benchmarkCommand;

package/dist/better-opn/index.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export declare const openBrowser: ({ url, browserFlag, browserArgs, }: {
+    url: string;
+    browserFlag: string | undefined;
+    browserArgs: string | undefined;
+}) => Promise<boolean | import("child_process").ChildProcess>;

package/dist/better-opn/index.js

@@ -0,0 +1,202 @@
+"use strict";
+// Copied from https://github.com/michaellzc/better-opn#readme
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const child_process_1 = require("child_process");
+const open = require("open");
+const normalizeURLToMatch = (target) => {
+    // We may encounter URL parse error but want to fallback to default behavior
+    try {
+        // Url module is deprecated on newer version of NodeJS, only use it when URL class is not supported (like Node 8)
+        const URL = typeof global.URL === 'undefined' ? require('url').URL : global.URL;
+        const url = new URL(target);
+        return url.origin;
+    }
+    catch (_a) {
+        return target;
+    }
+};
+// Copy from
+// https://github.com/facebook/create-react-app/blob/master/packages/react-dev-utils/openBrowser.js#L64
+const startBrowserProcess = async ({ browser, url, args, }) => {
+    const tryNewInstance = args.length > 0;
+    const shouldTryOpenChromiumWithAppleScript = process.platform === 'darwin' &&
+        !tryNewInstance &&
+        (typeof browser !== 'string' ||
+            browser === 'google chrome' ||
+            browser === 'chrome');
+    if (shouldTryOpenChromiumWithAppleScript) {
+        let appleScriptDenied = false;
+        // Will use the first open browser found from list
+        const supportedChromiumBrowsers = [
+            'Google Chrome',
+            'Google Chrome Canary',
+            'Microsoft Edge',
+            'Brave Browser',
+            'Vivaldi',
+            'Chromium',
+            'Arc',
+        ];
+        const processes = await new Promise((resolve, reject) => {
+            (0, child_process_1.exec)('ps cax', (err, stdout) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+        const browsersToTry = supportedChromiumBrowsers.filter((b) => processes.includes(b));
+        for (const chromiumBrowser of browsersToTry) {
+            if (appleScriptDenied) {
+                continue;
+            }
+            try {
+                // Try our best to reuse existing tab
+                // on OSX Chromium-based browser with AppleScript
+                const appleScript = `
+(*
+  Copyright (c) 2015-present, Facebook, Inc.
+  This source code is licensed under the MIT license found in the
+  LICENSE file in the root directory of this source tree.
+  *)
+  
+  property targetTab: null
+  property targetTabIndex: -1
+  property targetWindow: null
+  property theProgram: "${chromiumBrowser}"
+  
+  on run argv
+    set theURL to "${encodeURI(url)}"
+    set matchURL to "${process.env.OPEN_MATCH_HOST_ONLY === 'true'
+                    ? encodeURI(normalizeURLToMatch(url))
+                    : encodeURI(url)}"
+    
+    using terms from application "Google Chrome"
+      tell application theProgram
+  
+        if (count every window) = 0 then
+          make new window
+        end if
+  
+        -- 1: Looking for tab running debugger
+        -- then, Reload debugging tab if found
+        -- then return
+        set found to my lookupTabWithUrl(matchURL)
+        if found then
+          set targetWindow's active tab index to targetTabIndex
+          tell targetTab to reload
+          tell targetWindow to activate
+          set index of targetWindow to 1
+          return
+        end if
+  
+        -- 2: Looking for Empty tab
+        -- In case debugging tab was not found
+        -- We try to find an empty tab instead
+        set found to my lookupTabWithUrl("chrome://newtab/")
+        if found then
+          set targetWindow's active tab index to targetTabIndex
+          set URL of targetTab to theURL
+          tell targetWindow to activate
+          return
+        end if
+  
+        -- 3: Create new tab
+        -- both debugging and empty tab were not found
+        -- make a new tab with url
+        tell window 1
+          activate
+          make new tab with properties {URL:theURL}
+        end tell
+      end tell
+    end using terms from
+  end run
+  
+  -- Function:
+  -- Lookup tab with given url
+  -- if found, store tab, index, and window in properties
+  -- (properties were declared on top of file)
+  on lookupTabWithUrl(lookupUrl)
+    using terms from application "Google Chrome"
+      tell application theProgram
+        -- Find a tab with the given url
+        set found to false
+        set theTabIndex to -1
+        repeat with theWindow in every window
+          set theTabIndex to 0
+          repeat with theTab in every tab of theWindow
+            set theTabIndex to theTabIndex + 1
+            if (theTab's URL as string) contains lookupUrl then
+              -- assign tab, tab index, and window to properties
+              set targetTab to theTab
+              set targetTabIndex to theTabIndex
+              set targetWindow to theWindow
+              set found to true
+              exit repeat
+            end if
+          end repeat
+  
+          if found then
+            exit repeat
+          end if
+        end repeat
+      end tell
+    end using terms from
+    return found
+  end lookupTabWithUrl
+`.trim();
+                await new Promise((resolve, reject) => {
+                    const proc = (0, child_process_1.exec)(`osascript -`, (error) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            // Ignore errors.
+                            // It it breaks, it will fallback to `opn` anyway
+                            resolve();
+                        }
+                    });
+                    proc.stdin.write(appleScript);
+                    proc.stdin.end();
+                });
+                return Promise.resolve(true);
+            }
+            catch (error) {
+                const appleScriptError = error.message;
+                if (appleScriptError
+                    .toLowerCase()
+                    .includes('not authorised to send apple events')) {
+                    appleScriptDenied = true;
+                }
+                // Ignore errors.
+                // It it breaks, it will fallback to `opn` anyway
+            }
+        }
+    }
+    // Fallback to opn
+    // (It will always open new tab)
+    return open(url, {
+        ...(browser ? { app: { name: browser, arguments: args } } : {}),
+        newInstance: tryNewInstance,
+        wait: false,
+    });
+};
+const getBrowserArgs = (browserArgs) => {
+    if (browserArgs) {
+        return browserArgs.split(' ');
+    }
+    if (process.env.BROWSER_ARGS) {
+        return process.env.BROWSER_ARGS.split(' ');
+    }
+    return [];
+};
+const openBrowser = ({ url, browserFlag, browserArgs, }) => {
+    return startBrowserProcess({
+        browser: browserFlag !== null && browserFlag !== void 0 ? browserFlag : process.env.BROWSER,
+        url,
+        args: getBrowserArgs(browserArgs),
+    });
+};
+exports.openBrowser = openBrowser;

package/dist/cleanup-before-quit.d.ts

@@ -0,0 +1,3 @@
+export declare const cleanupBeforeQuit: () => void;
+export declare const registerCleanupJob: (job: () => void) => void;
+export declare const handleCtrlC: () => void;

package/dist/cleanup-before-quit.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCtrlC = exports.registerCleanupJob = exports.cleanupBeforeQuit = void 0;
+const log_1 = require("./log");
+const cleanupJobs = [];
+const cleanupBeforeQuit = () => {
+    for (const job of cleanupJobs) {
+        job();
+    }
+};
+exports.cleanupBeforeQuit = cleanupBeforeQuit;
+const registerCleanupJob = (job) => {
+    cleanupJobs.push(job);
+};
+exports.registerCleanupJob = registerCleanupJob;
+const handleCtrlC = () => {
+    process.on('SIGINT', () => {
+        log_1.Log.info();
+        (0, exports.cleanupBeforeQuit)();
+        process.exit(0);
+    });
+};
+exports.handleCtrlC = handleCtrlC;