@remotion/renderer 3.0.19 → 3.0.22

package/dist/browser/Target.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Copyright 2019 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 __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 __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 _Target_browserContext, _Target_targetInfo, _Target_sessionFactory, _Target_defaultViewport, _Target_pagePromise;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Target = void 0;
+const Page_1 = require("./Page");
+const isPagetTarget = (target) => {
+    return (target.type === 'page' ||
+        target.type === 'background_page' ||
+        target.type === 'webview');
+};
+class Target {
+    constructor(targetInfo, browserContext, sessionFactory, defaultViewport) {
+        _Target_browserContext.set(this, void 0);
+        _Target_targetInfo.set(this, void 0);
+        _Target_sessionFactory.set(this, void 0);
+        _Target_defaultViewport.set(this, void 0);
+        _Target_pagePromise.set(this, void 0);
+        __classPrivateFieldSet(this, _Target_targetInfo, targetInfo, "f");
+        __classPrivateFieldSet(this, _Target_browserContext, browserContext, "f");
+        this._targetId = targetInfo.targetId;
+        __classPrivateFieldSet(this, _Target_sessionFactory, sessionFactory, "f");
+        __classPrivateFieldSet(this, _Target_defaultViewport, defaultViewport, "f");
+        this._initializedPromise = new Promise((fulfill) => {
+            this._initializedCallback = fulfill;
+        }).then((success) => {
+            if (!success) {
+                return false;
+            }
+            const opener = this.opener();
+            if (!opener || !__classPrivateFieldGet(opener, _Target_pagePromise, "f") || this.type() !== 'page') {
+                return true;
+            }
+            return true;
+        });
+        this._isClosedPromise = new Promise((fulfill) => {
+            this._closedCallback = fulfill;
+        });
+        this._isInitialized =
+            !isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) || __classPrivateFieldGet(this, _Target_targetInfo, "f").url !== '';
+        if (this._isInitialized) {
+            this._initializedCallback(true);
+        }
+    }
+    /**
+     * Creates a Chrome Devtools Protocol session attached to the target.
+     */
+    createCDPSession() {
+        return __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this);
+    }
+    _getTargetInfo() {
+        return __classPrivateFieldGet(this, _Target_targetInfo, "f");
+    }
+    /**
+     * If the target is not of type `"page"` or `"background_page"`, returns `null`.
+     */
+    async page() {
+        var _a;
+        if (isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) && !__classPrivateFieldGet(this, _Target_pagePromise, "f")) {
+            __classPrivateFieldSet(this, _Target_pagePromise, __classPrivateFieldGet(this, _Target_sessionFactory, "f").call(this).then((client) => {
+                var _a;
+                return Page_1.Page._create(client, this, (_a = __classPrivateFieldGet(this, _Target_defaultViewport, "f")) !== null && _a !== void 0 ? _a : null);
+            }), "f");
+        }
+        return (_a = (await __classPrivateFieldGet(this, _Target_pagePromise, "f"))) !== null && _a !== void 0 ? _a : null;
+    }
+    url() {
+        return __classPrivateFieldGet(this, _Target_targetInfo, "f").url;
+    }
+    /**
+     * Identifies what kind of target this is.
+     *
+     * @remarks
+     *
+     * See {@link https://developer.chrome.com/extensions/background_pages | docs} for more info about background pages.
+     */
+    type() {
+        const { type } = __classPrivateFieldGet(this, _Target_targetInfo, "f");
+        if (type === 'page' ||
+            type === 'background_page' ||
+            type === 'service_worker' ||
+            type === 'shared_worker' ||
+            type === 'browser' ||
+            type === 'webview') {
+            return type;
+        }
+        return 'other';
+    }
+    /**
+     * Get the browser the target belongs to.
+     */
+    browser() {
+        return __classPrivateFieldGet(this, _Target_browserContext, "f").browser();
+    }
+    /**
+     * Get the browser context the target belongs to.
+     */
+    browserContext() {
+        return __classPrivateFieldGet(this, _Target_browserContext, "f");
+    }
+    /**
+     * Get the target that opened this target. Top-level targets return `null`.
+     */
+    opener() {
+        const { openerId } = __classPrivateFieldGet(this, _Target_targetInfo, "f");
+        if (!openerId) {
+            return;
+        }
+        return this.browser()._targets.get(openerId);
+    }
+    _targetInfoChanged(targetInfo) {
+        __classPrivateFieldSet(this, _Target_targetInfo, targetInfo, "f");
+        if (!this._isInitialized &&
+            (!isPagetTarget(__classPrivateFieldGet(this, _Target_targetInfo, "f")) || __classPrivateFieldGet(this, _Target_targetInfo, "f").url !== '')) {
+            this._isInitialized = true;
+            this._initializedCallback(true);
+        }
+    }
+}
+exports.Target = Target;
+_Target_browserContext = new WeakMap(), _Target_targetInfo = new WeakMap(), _Target_sessionFactory = new WeakMap(), _Target_defaultViewport = new WeakMap(), _Target_pagePromise = new WeakMap();

package/dist/browser/TaskQueue.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2020 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.
+ */
+export declare class TaskQueue {
+    #private;
+    constructor();
+    postTask<T>(task: () => Promise<T>): Promise<T>;
+}

package/dist/browser/TaskQueue.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Copyright 2020 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 __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 __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 _TaskQueue_chain;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskQueue = void 0;
+class TaskQueue {
+    constructor() {
+        _TaskQueue_chain.set(this, void 0);
+        __classPrivateFieldSet(this, _TaskQueue_chain, Promise.resolve(), "f");
+    }
+    postTask(task) {
+        const result = __classPrivateFieldGet(this, _TaskQueue_chain, "f").then(task);
+        __classPrivateFieldSet(this, _TaskQueue_chain, result.then(() => {
+            return undefined;
+        }, () => {
+            return undefined;
+        }), "f");
+        return result;
+    }
+}
+exports.TaskQueue = TaskQueue;
+_TaskQueue_chain = new WeakMap();

package/dist/browser/TimeoutSettings.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright 2019 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.
+ */
+export declare class TimeoutSettings {
+    #private;
+    constructor();
+    setDefaultTimeout(timeout: number): void;
+    setDefaultNavigationTimeout(timeout: number): void;
+    navigationTimeout(): number;
+    timeout(): number;
+}

package/dist/browser/TimeoutSettings.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * Copyright 2019 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 __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 __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 _TimeoutSettings_defaultTimeout, _TimeoutSettings_defaultNavigationTimeout;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutSettings = void 0;
+const DEFAULT_TIMEOUT = 30000;
+class TimeoutSettings {
+    constructor() {
+        _TimeoutSettings_defaultTimeout.set(this, void 0);
+        _TimeoutSettings_defaultNavigationTimeout.set(this, void 0);
+        __classPrivateFieldSet(this, _TimeoutSettings_defaultTimeout, null, "f");
+        __classPrivateFieldSet(this, _TimeoutSettings_defaultNavigationTimeout, null, "f");
+    }
+    setDefaultTimeout(timeout) {
+        __classPrivateFieldSet(this, _TimeoutSettings_defaultTimeout, timeout, "f");
+    }
+    setDefaultNavigationTimeout(timeout) {
+        __classPrivateFieldSet(this, _TimeoutSettings_defaultNavigationTimeout, timeout, "f");
+    }
+    navigationTimeout() {
+        if (__classPrivateFieldGet(this, _TimeoutSettings_defaultNavigationTimeout, "f") !== null) {
+            return __classPrivateFieldGet(this, _TimeoutSettings_defaultNavigationTimeout, "f");
+        }
+        if (__classPrivateFieldGet(this, _TimeoutSettings_defaultTimeout, "f") !== null) {
+            return __classPrivateFieldGet(this, _TimeoutSettings_defaultTimeout, "f");
+        }
+        return DEFAULT_TIMEOUT;
+    }
+    timeout() {
+        if (__classPrivateFieldGet(this, _TimeoutSettings_defaultTimeout, "f") !== null) {
+            return __classPrivateFieldGet(this, _TimeoutSettings_defaultTimeout, "f");
+        }
+        return DEFAULT_TIMEOUT;
+    }
+}
+exports.TimeoutSettings = TimeoutSettings;
+_TimeoutSettings_defaultTimeout = new WeakMap(), _TimeoutSettings_defaultNavigationTimeout = new WeakMap();

package/dist/browser/assert.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Copyright 2020 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.
+ */
+/**
+ * Asserts that the given value is truthy.
+ * @param value - some conditional statement
+ * @param message - the error message to throw if the value is not truthy.
+ */
+export declare const assert: (value: unknown, message?: string) => asserts value;

package/dist/browser/assert.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * Copyright 2020 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.assert = void 0;
+/**
+ * Asserts that the given value is truthy.
+ * @param value - some conditional statement
+ * @param message - the error message to throw if the value is not truthy.
+ */
+const assert = (value, message) => {
+    if (!value) {
+        throw new Error(message);
+    }
+};
+exports.assert = assert;

package/dist/browser/compat.d.ts

@@ -0,0 +1,2 @@
+declare let puppeteerDirname: string;
+export { puppeteerDirname };

package/dist/browser/compat.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.puppeteerDirname = void 0;
+const path_1 = require("path");
+let puppeteerDirname;
+exports.puppeteerDirname = puppeteerDirname;
+try {
+    // In some environments, like esbuild, this will throw an error.
+    // We suppress the error since the bundled binary is not expected
+    // to be used or installed in this case and, therefore, the
+    // root directory does not have to be known.
+    exports.puppeteerDirname = puppeteerDirname = (0, path_1.dirname)(require.resolve('./compat'));
+}
+catch (error) {
+    // Fallback to __dirname.
+    exports.puppeteerDirname = puppeteerDirname = __dirname;
+}

package/dist/browser/create-browser-fetcher.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Copyright 2020 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 { Product } from './Product';
+export declare function downloadBrowser(product: Product): Promise<void>;

package/dist/browser/create-browser-fetcher.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Copyright 2020 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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadBrowser = void 0;
+const https_1 = __importDefault(require("https"));
+const node_1 = require("./node");
+const revisions_1 = require("./revisions");
+const supportedProducts = {
+    chrome: 'Chromium',
+    firefox: 'Firefox Nightly',
+};
+async function downloadBrowser(product) {
+    const browserFetcher = node_1.puppeteer.createBrowserFetcher({
+        product,
+        path: null,
+        platform: null,
+    });
+    const revision = await getRevision();
+    await fetchBinary(revision);
+    async function getRevision() {
+        if (product === 'chrome') {
+            return Promise.resolve(revisions_1.PUPPETEER_REVISIONS.chromium);
+        }
+        if (product === 'firefox') {
+            node_1.puppeteer._preferredRevision = revisions_1.PUPPETEER_REVISIONS.firefox;
+            try {
+                return await getFirefoxNightlyVersion();
+            }
+            catch (error) {
+                console.error(error);
+                process.exit(1);
+            }
+        }
+        throw new Error(`Unsupported product ${product}`);
+    }
+    function fetchBinary(_revision) {
+        const revisionInfo = browserFetcher.revisionInfo(_revision);
+        // Do nothing if the revision is already downloaded.
+        if (revisionInfo.local) {
+            logPolitely(`${supportedProducts[product]} is already in ${revisionInfo.folderPath}; skipping download.`);
+            return;
+        }
+        function onSuccess(localRevisions) {
+            logPolitely(`${supportedProducts[product]} (${revisionInfo.revision}) downloaded to ${revisionInfo.folderPath}`);
+            localRevisions = localRevisions.filter((__revision) => {
+                return __revision !== revisionInfo.revision;
+            });
+            const cleanupOldVersions = localRevisions.map((__revision) => {
+                return browserFetcher.remove(__revision);
+            });
+            Promise.all([...cleanupOldVersions]);
+        }
+        function onError(error) {
+            console.error(`ERROR: Failed to set up ${supportedProducts[product]} r${_revision}! Set "PUPPETEER_SKIP_DOWNLOAD" env variable to skip download.`);
+            console.error(error);
+            process.exit(1);
+        }
+        function onProgress(downloadedBytes, totalBytes) {
+            console.log('Downloading', supportedProducts[product], toMegabytes(downloadedBytes) + '/' + toMegabytes(totalBytes));
+        }
+        return browserFetcher
+            .download(revisionInfo.revision, onProgress)
+            .then(() => {
+            return browserFetcher.localRevisions();
+        })
+            .then(onSuccess)
+            .catch(onError);
+    }
+    function toMegabytes(bytes) {
+        const mb = bytes / 1024 / 1024;
+        return `${Math.round(mb * 10) / 10} Mb`;
+    }
+    function getFirefoxNightlyVersion() {
+        const firefoxVersionsUrl = 'https://product-details.mozilla.org/1.0/firefox_versions.json';
+        const requestOptions = {};
+        const promise = new Promise((resolve, reject) => {
+            let data = '';
+            logPolitely(`Requesting latest Firefox Nightly version from ${firefoxVersionsUrl}`);
+            https_1.default
+                .get(firefoxVersionsUrl, requestOptions, (r) => {
+                if (r.statusCode && r.statusCode >= 400) {
+                    return reject(new Error(`Got status code ${r.statusCode}`));
+                }
+                r.on('data', (chunk) => {
+                    data += chunk;
+                });
+                r.on('end', () => {
+                    try {
+                        const versions = JSON.parse(data);
+                        return resolve(versions.FIREFOX_NIGHTLY);
+                    }
+                    catch (_a) {
+                        return reject(new Error('Firefox version not found'));
+                    }
+                });
+            })
+                .on('error', reject);
+        });
+        return promise;
+    }
+}
+exports.downloadBrowser = downloadBrowser;
+function logPolitely(toBeLogged) {
+    const logLevel = process.env.npm_config_loglevel || '';
+    const logLevelDisplay = ['silent', 'error', 'warn'].indexOf(logLevel) > -1;
+    // eslint-disable-next-line no-console
+    if (!logLevelDisplay) {
+        console.log(toBeLogged);
+    }
+}

package/dist/browser/environment.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2020 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.
+ */
+export declare const isNode: boolean;

package/dist/browser/environment.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Copyright 2020 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.isNode = void 0;
+exports.isNode = Boolean(typeof process !== 'undefined' && process.version);

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

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

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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const getDownloadsCacheDir = () => {
+    const cwd = process.cwd();
+    let dir = cwd;
+    for (;;) {
+        try {
+            if (fs_1.default.statSync(path_1.default.join(dir, 'package.json')).isFile()) {
+                break;
+            }
+            // eslint-disable-next-line no-empty
+        }
+        catch (e) { }
+        const parent = path_1.default.dirname(dir);
+        if (dir === parent) {
+            dir = undefined;
+            break;
+        }
+        dir = parent;
+    }
+    if (!dir) {
+        return path_1.default.resolve(cwd, '.remotion');
+    }
+    if (process.versions.pnp === '1') {
+        return path_1.default.resolve(dir, '.pnp/.remotion');
+    }
+    if (process.versions.pnp === '3') {
+        return path_1.default.resolve(dir, '.yarn/.remotion');
+    }
+    return path_1.default.resolve(dir, 'node_modules/.remotion');
+};
+exports.getDownloadsCacheDir = getDownloadsCacheDir;

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

@@ -0,0 +1,22 @@
+export declare type EventType = string | symbol;
+export declare type Handler<T = any> = (event?: T) => void;
+declare type WildcardHandler = (type: EventType, event?: any) => void;
+declare type EventHandlerList = Array<Handler>;
+declare type WildCardEventHandlerList = Array<WildcardHandler>;
+declare 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 {};