@remotion/renderer 4.0.357 → 4.0.360

package/package/dist/assets/truncate-utf8-bytes.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateUtf8Bytes = truncateUtf8Bytes;
+function isHighSurrogate(codePoint) {
+    return codePoint >= 0xd800 && codePoint <= 0xdbff;
+}
+function isLowSurrogate(codePoint) {
+    return codePoint >= 0xdc00 && codePoint <= 0xdfff;
+}
+const getLength = Buffer.byteLength.bind(Buffer);
+function truncateUtf8Bytes(string, byteLength) {
+    if (typeof string !== 'string') {
+        throw new Error('Input must be string');
+    }
+    const charLength = string.length;
+    let curByteLength = 0;
+    let codePoint;
+    let segment;
+    for (let i = 0; i < charLength; i += 1) {
+        codePoint = string.charCodeAt(i);
+        segment = string[i];
+        if (isHighSurrogate(codePoint) &&
+            isLowSurrogate(string.charCodeAt(i + 1))) {
+            i += 1;
+            segment += string[i];
+        }
+        curByteLength += getLength(segment);
+        if (curByteLength === byteLength) {
+            return string.slice(0, i + 1);
+        }
+        if (curByteLength > byteLength) {
+            return string.slice(0, i - segment.length + 1);
+        }
+    }
+    return string;
+}

package/package/dist/assets/types.d.ts

@@ -0,0 +1,18 @@
+import type { AudioOrVideoAsset } from 'remotion/no-react';
+export type UnsafeAsset = Omit<AudioOrVideoAsset, 'frame' | 'id' | 'volume' | 'mediaFrame' | 'audioStartFrom'> & {
+    startInVideo: number;
+    duration: number | null;
+    trimLeft: number;
+    volume: number[];
+    id: string;
+    playbackRate: number;
+    toneFrequency: number;
+    audioStreamIndex: number;
+};
+export type AssetVolume = number | number[];
+export type MediaAsset = Omit<UnsafeAsset, 'duration' | 'volume'> & {
+    duration: number;
+    volume: AssetVolume;
+};
+export declare const uncompressMediaAsset: (allRenderAssets: AudioOrVideoAsset[], assetToUncompress: AudioOrVideoAsset) => AudioOrVideoAsset;
+export type Assets = MediaAsset[];

package/package/dist/assets/types.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uncompressMediaAsset = void 0;
+const uncompressMediaAsset = (allRenderAssets, assetToUncompress) => {
+    const isCompressed = assetToUncompress.src.match(/same-as-(.*)-([0-9.]+)$/);
+    if (!isCompressed) {
+        return assetToUncompress;
+    }
+    const [, id, frame] = isCompressed;
+    const assetToFill = allRenderAssets.find((a) => a.id === id && String(a.frame) === frame);
+    if (!assetToFill) {
+        console.log('List of assets:');
+        console.log(allRenderAssets);
+        throw new TypeError(`Cannot uncompress asset, asset list seems corrupt. Please file a bug in the Remotion repo with the debug information above.`);
+    }
+    return {
+        ...assetToUncompress,
+        src: assetToFill.src,
+    };
+};
+exports.uncompressMediaAsset = uncompressMediaAsset;

package/package/dist/browser/Browser.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 { BrowserLog } from '../browser-log';
+import type { LogLevel } from '../log-level';
+import type { OnLog, Page } from './BrowserPage';
+import type { BrowserRunner } from './BrowserRunner';
+import type { Connection } from './Connection';
+import { EventEmitter } from './EventEmitter';
+import type { Viewport } from './PuppeteerViewport';
+import type { SourceMapGetter } from './source-map-getter';
+import { Target } from './Target';
+interface WaitForTargetOptions {
+    timeout?: number;
+}
+export declare const enum BrowserEmittedEvents {
+    TargetChanged = "targetchanged",
+    TargetCreated = "targetcreated",
+    Closed = "closed",
+    ClosedSilent = "closed-silent"
+}
+export declare class HeadlessBrowser extends EventEmitter {
+    #private;
+    static create({ defaultViewport, timeout, userDataDir, args, executablePath, logLevel, indent, }: {
+        defaultViewport: Viewport;
+        timeout: number;
+        userDataDir: string;
+        args: string[];
+        executablePath: string;
+        logLevel: LogLevel;
+        indent: boolean;
+    }): Promise<HeadlessBrowser>;
+    connection: Connection;
+    id: string;
+    runner: BrowserRunner;
+    get _targets(): Map<string, Target>;
+    constructor({ connection, defaultViewport, runner, }: {
+        connection: Connection;
+        defaultViewport: Viewport;
+        runner: BrowserRunner;
+    });
+    browserContexts(): BrowserContext[];
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+        onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
+    }): Promise<Page>;
+    _createPageInContext({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+        onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
+    }): Promise<Page>;
+    targets(): Target[];
+    waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: WaitForTargetOptions): Promise<Target>;
+    pages(): Promise<Page[]>;
+    close({ silent }: {
+        silent: boolean;
+    }): Promise<void>;
+    disconnect(): void;
+}
+export declare class BrowserContext extends EventEmitter {
+    #private;
+    constructor(browser: HeadlessBrowser);
+    targets(): Target[];
+    waitForTarget(predicate: (x: Target) => boolean | Promise<boolean>, options?: {
+        timeout?: number;
+    }): Promise<Target>;
+    pages(): Promise<Page[]>;
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }: {
+        context: SourceMapGetter;
+        logLevel: LogLevel;
+        indent: boolean;
+        pageIndex: number;
+        onBrowserLog: null | ((log: BrowserLog) => void);
+        onLog: OnLog;
+    }): Promise<Page>;
+    browser(): HeadlessBrowser;
+}
+export {};

package/package/dist/browser/Browser.js

@@ -0,0 +1,246 @@
+"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.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _HeadlessBrowser_instances, _HeadlessBrowser_defaultViewport, _HeadlessBrowser_defaultContext, _HeadlessBrowser_contexts, _HeadlessBrowser_targets, _HeadlessBrowser_targetCreated, _HeadlessBrowser_targetDestroyed, _HeadlessBrowser_targetInfoChanged, _BrowserContext_browser;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserContext = exports.HeadlessBrowser = void 0;
+const assert_1 = require("./assert");
+const BrowserRunner_1 = require("./BrowserRunner");
+const EventEmitter_1 = require("./EventEmitter");
+const Target_1 = require("./Target");
+const util_1 = require("./util");
+class HeadlessBrowser extends EventEmitter_1.EventEmitter {
+    static async create({ defaultViewport, timeout, userDataDir, args, executablePath, logLevel, indent, }) {
+        const runner = await (0, BrowserRunner_1.makeBrowserRunner)({
+            executablePath,
+            processArguments: args,
+            userDataDir,
+            indent,
+            logLevel,
+            timeout,
+        });
+        const browser = new HeadlessBrowser({
+            connection: runner.connection,
+            defaultViewport,
+            runner,
+        });
+        await runner.connection.send('Target.setDiscoverTargets', { discover: true });
+        return browser;
+    }
+    get _targets() {
+        return __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f");
+    }
+    constructor({ connection, defaultViewport, runner, }) {
+        super();
+        _HeadlessBrowser_instances.add(this);
+        _HeadlessBrowser_defaultViewport.set(this, void 0);
+        _HeadlessBrowser_defaultContext.set(this, void 0);
+        _HeadlessBrowser_contexts.set(this, void 0);
+        _HeadlessBrowser_targets.set(this, void 0);
+        __classPrivateFieldSet(this, _HeadlessBrowser_defaultViewport, defaultViewport, "f");
+        this.connection = connection;
+        this.id = Math.random().toString(36).substring(2, 15);
+        __classPrivateFieldSet(this, _HeadlessBrowser_defaultContext, new BrowserContext(this), "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_contexts, new Map(), "f");
+        __classPrivateFieldSet(this, _HeadlessBrowser_targets, new Map(), "f");
+        this.connection.on('Target.targetCreated', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetCreated).bind(this));
+        this.connection.on('Target.targetDestroyed', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetDestroyed).bind(this));
+        this.connection.on('Target.targetInfoChanged', __classPrivateFieldGet(this, _HeadlessBrowser_instances, "m", _HeadlessBrowser_targetInfoChanged).bind(this));
+        this.runner = runner;
+    }
+    browserContexts() {
+        return [__classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f"), ...Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").values())];
+    }
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }) {
+        return __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f").newPage({
+            context,
+            logLevel,
+            indent,
+            pageIndex,
+            onBrowserLog,
+            onLog,
+        });
+    }
+    async _createPageInContext({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }) {
+        const { value: { targetId }, } = await this.connection.send('Target.createTarget', {
+            url: 'about:blank',
+            browserContextId: undefined,
+        });
+        const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(targetId);
+        if (!target) {
+            throw new Error(`Missing target for page (id = ${targetId})`);
+        }
+        const initialized = await target._initializedPromise;
+        if (!initialized) {
+            throw new Error(`Failed to create target for page (id = ${targetId})`);
+        }
+        const page = await target.page({
+            sourceMapGetter: context,
+            logLevel,
+            indent,
+            pageIndex,
+            onBrowserLog,
+            onLog,
+        });
+        if (!page) {
+            throw new Error(`Failed to create a page for context`);
+        }
+        return page;
+    }
+    targets() {
+        return Array.from(__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").values()).filter((target) => {
+            return target._isInitialized;
+        });
+    }
+    async waitForTarget(predicate, options = {}) {
+        const { timeout = 30000 } = options;
+        let resolve;
+        let isResolved = false;
+        const targetPromise = new Promise((x) => {
+            resolve = x;
+        });
+        this.on("targetcreated" /* BrowserEmittedEvents.TargetCreated */, check);
+        this.on("targetchanged" /* BrowserEmittedEvents.TargetChanged */, check);
+        try {
+            if (!timeout) {
+                return await targetPromise;
+            }
+            this.targets().forEach(check);
+            return await (0, util_1.waitWithTimeout)(targetPromise, 'target', timeout, this);
+        }
+        finally {
+            this.off("targetcreated" /* BrowserEmittedEvents.TargetCreated */, check);
+            this.off("targetchanged" /* BrowserEmittedEvents.TargetChanged */, check);
+        }
+        async function check(target) {
+            if ((await predicate(target)) && !isResolved) {
+                isResolved = true;
+                resolve(target);
+            }
+        }
+    }
+    async pages() {
+        const contextPages = await Promise.all(this.browserContexts().map((context) => {
+            return context.pages();
+        }));
+        // Flatten array.
+        return contextPages.reduce((acc, x) => {
+            return acc.concat(x);
+        }, []);
+    }
+    async close({ silent }) {
+        await this.runner.closeProcess();
+        (await this.pages()).forEach((page) => {
+            page.emit("disposed" /* PageEmittedEvents.Disposed */);
+            page.closed = true;
+        });
+        this.disconnect();
+        this.emit(silent ? "closed-silent" /* BrowserEmittedEvents.ClosedSilent */ : "closed" /* BrowserEmittedEvents.Closed */);
+    }
+    disconnect() {
+        this.connection.dispose();
+    }
+}
+exports.HeadlessBrowser = HeadlessBrowser;
+_HeadlessBrowser_defaultViewport = new WeakMap(), _HeadlessBrowser_defaultContext = new WeakMap(), _HeadlessBrowser_contexts = new WeakMap(), _HeadlessBrowser_targets = new WeakMap(), _HeadlessBrowser_instances = new WeakSet(), _HeadlessBrowser_targetCreated = async function _HeadlessBrowser_targetCreated(event) {
+    var _a;
+    const { targetInfo } = event;
+    const { browserContextId } = targetInfo;
+    const context = browserContextId && __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").has(browserContextId)
+        ? __classPrivateFieldGet(this, _HeadlessBrowser_contexts, "f").get(browserContextId)
+        : __classPrivateFieldGet(this, _HeadlessBrowser_defaultContext, "f");
+    if (!context) {
+        throw new Error('Missing browser context');
+    }
+    const target = new Target_1.Target(targetInfo, context, () => {
+        return this.connection.createSession(targetInfo);
+    }, (_a = __classPrivateFieldGet(this, _HeadlessBrowser_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
+    (0, assert_1.assert)(!__classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").has(event.targetInfo.targetId), 'Target should not exist before targetCreated');
+    __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").set(event.targetInfo.targetId, target);
+    if (await target._initializedPromise) {
+        this.emit("targetcreated" /* BrowserEmittedEvents.TargetCreated */, target);
+    }
+}, _HeadlessBrowser_targetDestroyed = function _HeadlessBrowser_targetDestroyed(event) {
+    const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetId);
+    if (!target) {
+        throw new Error(`Missing target in _targetDestroyed (id = ${event.targetId})`);
+    }
+    target._initializedCallback(false);
+    __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").delete(event.targetId);
+    target._closedCallback();
+}, _HeadlessBrowser_targetInfoChanged = function _HeadlessBrowser_targetInfoChanged(event) {
+    const target = __classPrivateFieldGet(this, _HeadlessBrowser_targets, "f").get(event.targetInfo.targetId);
+    if (!target) {
+        throw new Error(`Missing target in targetInfoChanged (id = ${event.targetInfo.targetId})`);
+    }
+    const previousURL = target.url();
+    const wasInitialized = target._isInitialized;
+    target._targetInfoChanged(event.targetInfo);
+    if (wasInitialized && previousURL !== target.url()) {
+        this.emit("targetchanged" /* BrowserEmittedEvents.TargetChanged */, target);
+    }
+};
+class BrowserContext extends EventEmitter_1.EventEmitter {
+    constructor(browser) {
+        super();
+        _BrowserContext_browser.set(this, void 0);
+        __classPrivateFieldSet(this, _BrowserContext_browser, browser, "f");
+    }
+    targets() {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f").targets().filter((target) => {
+            return target.browserContext() === this;
+        });
+    }
+    waitForTarget(predicate, options = {}) {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f").waitForTarget((target) => {
+            return target.browserContext() === this && predicate(target);
+        }, options);
+    }
+    async pages() {
+        const pages = await Promise.all(this.targets()
+            .filter((target) => target.type() === 'page')
+            .map((target) => target.expectPage()));
+        return pages.filter((page) => {
+            return Boolean(page);
+        });
+    }
+    newPage({ context, logLevel, indent, pageIndex, onBrowserLog, onLog, }) {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f")._createPageInContext({
+            context,
+            logLevel,
+            indent,
+            pageIndex,
+            onBrowserLog,
+            onLog,
+        });
+    }
+    browser() {
+        return __classPrivateFieldGet(this, _BrowserContext_browser, "f");
+    }
+}
+exports.BrowserContext = BrowserContext;
+_BrowserContext_browser = new WeakMap();

package/package/dist/browser/BrowserFetcher.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 { LogLevel } from '../log-level';
+import { ChromeMode } from '../options/chrome-mode';
+import type { DownloadBrowserProgressFn } from '../options/on-browser-download';
+interface BrowserFetcherRevisionInfo {
+    folderPath: string;
+    executablePath: string;
+    url: string;
+    local: boolean;
+}
+export declare const downloadBrowser: ({ logLevel, indent, onProgress, version, chromeMode, }: {
+    logLevel: LogLevel;
+    indent: boolean;
+    onProgress: DownloadBrowserProgressFn;
+    version: string | null;
+    chromeMode: ChromeMode;
+}) => Promise<BrowserFetcherRevisionInfo | undefined>;
+export declare const getRevisionInfo: (chromeMode: ChromeMode) => BrowserFetcherRevisionInfo;
+export {};

package/package/dist/browser/BrowserFetcher.js

@@ -0,0 +1,215 @@
+"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.
+ */
+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.getRevisionInfo = exports.downloadBrowser = void 0;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const extract_zip_1 = __importDefault(require("extract-zip"));
+const node_util_1 = require("node:util");
+const download_file_1 = require("../assets/download-file");
+const make_file_executable_1 = require("../compositor/make-file-executable");
+const get_download_destination_1 = require("./get-download-destination");
+const TESTED_VERSION = '134.0.6998.35';
+// https://github.com/microsoft/playwright/tree/v1.51.0
+// packages/playwright-core/browsers.json
+const PLAYWRIGHT_VERSION = '1161'; // 134.0.6998.35
+function getChromeDownloadUrl({ platform, version, chromeMode, }) {
+    if (platform === 'linux-arm64') {
+        if (chromeMode === 'chrome-for-testing') {
+            return `https://playwright.azureedge.net/builds/chromium/${version !== null && version !== void 0 ? version : PLAYWRIGHT_VERSION}/chromium-linux-arm64.zip`;
+        }
+        return `https://playwright.azureedge.net/builds/chromium/${version !== null && version !== void 0 ? version : PLAYWRIGHT_VERSION}/chromium-headless-shell-linux-arm64.zip`;
+    }
+    if (chromeMode === 'headless-shell') {
+        return `https://storage.googleapis.com/chrome-for-testing-public/${version !== null && version !== void 0 ? version : TESTED_VERSION}/${platform}/chrome-headless-shell-${platform}.zip`;
+    }
+    return `https://storage.googleapis.com/chrome-for-testing-public/${version !== null && version !== void 0 ? version : TESTED_VERSION}/${platform}/chrome-${platform}.zip`;
+}
+const mkdirAsync = fs.promises.mkdir;
+const unlinkAsync = (0, node_util_1.promisify)(fs.unlink.bind(fs));
+function existsAsync(filePath) {
+    return new Promise((resolve) => {
+        fs.access(filePath, (err) => {
+            return resolve(!err);
+        });
+    });
+}
+const getPlatform = () => {
+    const platform = os.platform();
+    switch (platform) {
+        case 'darwin':
+            return os.arch() === 'arm64' ? 'mac-arm64' : 'mac-x64';
+        case 'linux':
+            return os.arch() === 'arm64' ? 'linux-arm64' : 'linux64';
+        case 'win32':
+            return 'win64';
+        default:
+            throw new Error('Unsupported platform: ' + platform);
+    }
+};
+const getDownloadsFolder = (chromeMode) => {
+    const destination = chromeMode === 'headless-shell'
+        ? 'chrome-headless-shell'
+        : 'chrome-for-testing';
+    return path.join((0, get_download_destination_1.getDownloadsCacheDir)(), destination);
+};
+const downloadBrowser = async ({ logLevel, indent, onProgress, version, chromeMode, }) => {
+    const platform = getPlatform();
+    const downloadURL = getChromeDownloadUrl({ platform, version, chromeMode });
+    const fileName = downloadURL.split('/').pop();
+    if (!fileName) {
+        throw new Error(`A malformed download URL was found: ${downloadURL}.`);
+    }
+    const downloadsFolder = getDownloadsFolder(chromeMode);
+    const archivePath = path.join(downloadsFolder, fileName);
+    const outputPath = getFolderPath(downloadsFolder, platform);
+    if (await existsAsync(outputPath)) {
+        return (0, exports.getRevisionInfo)(chromeMode);
+    }
+    if (!(await existsAsync(downloadsFolder))) {
+        await mkdirAsync(downloadsFolder, {
+            recursive: true,
+        });
+    }
+    if (os.platform() !== 'darwin' &&
+        os.platform() !== 'linux' &&
+        os.arch() === 'arm64') {
+        throw new Error([
+            'Chrome Headless Shell is not available for Windows for arm64 architecture.',
+        ].join('\n'));
+    }
+    try {
+        await (0, download_file_1.downloadFile)({
+            url: downloadURL,
+            to: () => archivePath,
+            onProgress: (progress) => {
+                if (progress.totalSize === null || progress.percent === null) {
+                    throw new Error('Expected totalSize and percent to be defined');
+                }
+                onProgress({
+                    downloadedBytes: progress.downloaded,
+                    totalSizeInBytes: progress.totalSize,
+                    percent: progress.percent,
+                });
+            },
+            indent,
+            logLevel,
+        });
+        await (0, extract_zip_1.default)(archivePath, { dir: outputPath });
+        const chromePath = path.join(outputPath, 'chrome-linux', 'chrome');
+        const chromeHeadlessShellPath = path.join(outputPath, 'chrome-linux', 'chrome-headless-shell');
+        if (fs.existsSync(chromePath)) {
+            fs.renameSync(chromePath, chromeHeadlessShellPath);
+        }
+        const chromeLinuxFolder = path.join(outputPath, 'chrome-linux');
+        if (fs.existsSync(chromeLinuxFolder)) {
+            fs.renameSync(chromeLinuxFolder, path.join(outputPath, 'chrome-headless-shell-linux-arm64'));
+        }
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+    finally {
+        if (await existsAsync(archivePath)) {
+            await unlinkAsync(archivePath);
+        }
+    }
+    const revisionInfo = (0, exports.getRevisionInfo)(chromeMode);
+    (0, make_file_executable_1.makeFileExecutableIfItIsNot)(revisionInfo.executablePath);
+    return revisionInfo;
+};
+exports.downloadBrowser = downloadBrowser;
+const getFolderPath = (downloadsFolder, platform) => {
+    return path.resolve(downloadsFolder, platform);
+};
+const getExecutablePath = (chromeMode) => {
+    const downloadsFolder = getDownloadsFolder(chromeMode);
+    const platform = getPlatform();
+    const folderPath = getFolderPath(downloadsFolder, platform);
+    if (chromeMode === 'chrome-for-testing') {
+        if (platform === 'mac-arm64' || platform === 'mac-x64') {
+            return path.join(folderPath, `chrome-${platform}`, 'Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing');
+        }
+        if (platform === 'win64') {
+            return path.join(folderPath, 'chrome-win64', 'chrome.exe');
+        }
+        if (platform === 'linux64' || platform === 'linux-arm64') {
+            return path.join(folderPath, 'chrome-linux64', 'chrome');
+        }
+        throw new Error('unsupported platform' + platform);
+    }
+    if (chromeMode === 'headless-shell') {
+        return path.join(folderPath, `chrome-headless-shell-${platform}`, platform === 'win64'
+            ? 'chrome-headless-shell.exe'
+            : platform === 'linux-arm64'
+                ? 'headless_shell'
+                : 'chrome-headless-shell');
+    }
+    throw new Error('unsupported chrome mode' + chromeMode);
+};
+const getRevisionInfo = (chromeMode) => {
+    const executablePath = getExecutablePath(chromeMode);
+    const downloadsFolder = getDownloadsFolder(chromeMode);
+    const platform = getPlatform();
+    const folderPath = getFolderPath(downloadsFolder, platform);
+    const url = getChromeDownloadUrl({ platform, version: null, chromeMode });
+    const local = fs.existsSync(folderPath);
+    return {
+        executablePath,
+        folderPath,
+        local,
+        url,
+    };
+};
+exports.getRevisionInfo = getRevisionInfo;