@remotion/renderer 4.0.0-preload.17 → 4.0.0-skia.20

package/dist/browser/page.js

@@ -0,0 +1,283 @@
+"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 __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 _Page_instances, _Page_closed, _Page_client, _Page_target, _Page_timeoutSettings, _Page_frameManager, _Page_pageBindings, _Page_initialize, _Page_onTargetCrashed, _Page_onLogEntryAdded, _Page_onConsoleAPI, _Page_onBindingCalled, _Page_addConsoleMessage;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const assert_1 = require("./assert");
+const ConsoleMessage_1 = require("./ConsoleMessage");
+const EventEmitter_1 = require("./EventEmitter");
+const FrameManager_1 = require("./FrameManager");
+const JSHandle_1 = require("./JSHandle");
+const TaskQueue_1 = require("./TaskQueue");
+const TimeoutSettings_1 = require("./TimeoutSettings");
+const util_1 = require("./util");
+class Page extends EventEmitter_1.EventEmitter {
+    constructor(client, target, browser) {
+        super();
+        _Page_instances.add(this);
+        _Page_closed.set(this, false);
+        _Page_client.set(this, void 0);
+        _Page_target.set(this, void 0);
+        _Page_timeoutSettings.set(this, new TimeoutSettings_1.TimeoutSettings());
+        _Page_frameManager.set(this, void 0);
+        _Page_pageBindings.set(this, new Map());
+        __classPrivateFieldSet(this, _Page_client, client, "f");
+        __classPrivateFieldSet(this, _Page_target, target, "f");
+        __classPrivateFieldSet(this, _Page_frameManager, new FrameManager_1.FrameManager(client, this, __classPrivateFieldGet(this, _Page_timeoutSettings, "f")), "f");
+        this.screenshotTaskQueue = new TaskQueue_1.TaskQueue();
+        this.browser = browser;
+        client.on('Target.attachedToTarget', (event) => {
+            switch (event.targetInfo.type) {
+                case 'iframe':
+                    break;
+                case 'worker':
+                    break;
+                default:
+                    // If we don't detach from service workers, they will never die.
+                    // We still want to attach to workers for emitting events.
+                    // We still want to attach to iframes so sessions may interact with them.
+                    // We detach from all other types out of an abundance of caution.
+                    // See https://source.chromium.org/chromium/chromium/src/+/main:content/browser/devtools/devtools_agent_host_impl.cc?ss=chromium&q=f:devtools%20-f:out%20%22::kTypePage%5B%5D%22
+                    // for the complete list of available types.
+                    client
+                        .send('Target.detachFromTarget', {
+                        sessionId: event.sessionId,
+                    })
+                        .catch((err) => console.log(err));
+            }
+        });
+        client.on('Runtime.consoleAPICalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onConsoleAPI).call(this, event);
+        });
+        client.on('Runtime.bindingCalled', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onBindingCalled).call(this, event);
+        });
+        client.on('Inspector.targetCrashed', () => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onTargetCrashed).call(this);
+        });
+        client.on('Log.entryAdded', (event) => {
+            return __classPrivateFieldGet(this, _Page_instances, "m", _Page_onLogEntryAdded).call(this, event);
+        });
+    }
+    static async _create(client, target, defaultViewport, browser) {
+        const page = new Page(client, target, browser);
+        await __classPrivateFieldGet(page, _Page_instances, "m", _Page_initialize).call(page);
+        await page.setViewport(defaultViewport);
+        return page;
+    }
+    /**
+     * Listen to page events.
+     */
+    // Note: this method exists to define event typings and handle
+    // proper wireup of cooperative request interception. Actual event listening and
+    // dispatching is delegated to EventEmitter.
+    on(eventName, handler) {
+        return super.on(eventName, handler);
+    }
+    once(eventName, handler) {
+        // Note: this method only exists to define the types; we delegate the impl
+        // to EventEmitter.
+        return super.once(eventName, handler);
+    }
+    off(eventName, handler) {
+        return super.off(eventName, handler);
+    }
+    /**
+     * @returns A target this page was created from.
+     */
+    target() {
+        return __classPrivateFieldGet(this, _Page_target, "f");
+    }
+    _client() {
+        return __classPrivateFieldGet(this, _Page_client, "f");
+    }
+    /**
+     * @returns The page's main frame.
+     * @remarks
+     * Page is guaranteed to have a main frame which persists during navigations.
+     */
+    mainFrame() {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame();
+    }
+    setViewport(viewport) {
+        return __classPrivateFieldGet(this, _Page_client, "f").send('Emulation.setDeviceMetricsOverride', {
+            mobile: false,
+            width: viewport.width,
+            height: viewport.height,
+            deviceScaleFactor: viewport.deviceScaleFactor,
+            screenOrientation: {
+                angle: 0,
+                type: 'portraitPrimary',
+            },
+        });
+    }
+    setDefaultNavigationTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultNavigationTimeout(timeout);
+    }
+    setDefaultTimeout(timeout) {
+        __classPrivateFieldGet(this, _Page_timeoutSettings, "f").setDefaultTimeout(timeout);
+    }
+    async evaluateHandle(pageFunction, ...args) {
+        const context = await this.mainFrame().executionContext();
+        return context.evaluateHandle(pageFunction, ...args);
+    }
+    url() {
+        return this.mainFrame().url();
+    }
+    goto(url, options = {}) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().goto(url, options);
+    }
+    async bringToFront() {
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.bringToFront');
+    }
+    evaluate(pageFunction, ...args) {
+        return __classPrivateFieldGet(this, _Page_frameManager, "f").mainFrame().evaluate(pageFunction, ...args);
+    }
+    async evaluateOnNewDocument(pageFunction, ...args) {
+        const source = (0, util_1.evaluationString)(pageFunction, ...args);
+        await __classPrivateFieldGet(this, _Page_client, "f").send('Page.addScriptToEvaluateOnNewDocument', {
+            source,
+        });
+    }
+    async close(options = { runBeforeUnload: undefined }) {
+        const connection = __classPrivateFieldGet(this, _Page_client, "f").connection();
+        (0, assert_1.assert)(connection, 'Protocol error: Connection closed. Most likely the page has been closed.');
+        const runBeforeUnload = Boolean(options.runBeforeUnload);
+        if (runBeforeUnload) {
+            await __classPrivateFieldGet(this, _Page_client, "f").send('Page.close');
+        }
+        else {
+            await connection.send('Target.closeTarget', {
+                targetId: __classPrivateFieldGet(this, _Page_target, "f")._targetId,
+            });
+            await __classPrivateFieldGet(this, _Page_target, "f")._isClosedPromise;
+        }
+    }
+    isClosed() {
+        return __classPrivateFieldGet(this, _Page_closed, "f");
+    }
+    waitForFunction(browser, pageFunction, ...args) {
+        return this.mainFrame().waitForFunction(browser, pageFunction, ...args);
+    }
+}
+exports.Page = Page;
+_Page_closed = new WeakMap(), _Page_client = new WeakMap(), _Page_target = new WeakMap(), _Page_timeoutSettings = new WeakMap(), _Page_frameManager = new WeakMap(), _Page_pageBindings = new WeakMap(), _Page_instances = new WeakSet(), _Page_initialize = async function _Page_initialize() {
+    await Promise.all([
+        __classPrivateFieldGet(this, _Page_frameManager, "f").initialize(),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Target.setAutoAttach', {
+            autoAttach: true,
+            waitForDebuggerOnStart: false,
+            flatten: true,
+        }),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Performance.enable'),
+        __classPrivateFieldGet(this, _Page_client, "f").send('Log.enable'),
+    ]);
+}, _Page_onTargetCrashed = function _Page_onTargetCrashed() {
+    this.emit('error', new Error('Page crashed!'));
+}, _Page_onLogEntryAdded = function _Page_onLogEntryAdded(event) {
+    const { level, text, args, source, url, lineNumber } = event.entry;
+    if (args) {
+        args.map((arg) => {
+            return (0, util_1.releaseObject)(__classPrivateFieldGet(this, _Page_client, "f"), arg);
+        });
+    }
+    if (source !== 'worker') {
+        this.emit("console" /* PageEmittedEvents.Console */, new ConsoleMessage_1.ConsoleMessage(level, text, [], [{ url, lineNumber }]));
+    }
+}, _Page_onConsoleAPI = function _Page_onConsoleAPI(event) {
+    if (event.executionContextId === 0) {
+        return;
+    }
+    const context = __classPrivateFieldGet(this, _Page_frameManager, "f").executionContextById(event.executionContextId, __classPrivateFieldGet(this, _Page_client, "f"));
+    const values = event.args.map((arg) => {
+        return (0, JSHandle_1._createJSHandle)(context, arg);
+    });
+    __classPrivateFieldGet(this, _Page_instances, "m", _Page_addConsoleMessage).call(this, event.type, values, event.stackTrace);
+}, _Page_onBindingCalled = async function _Page_onBindingCalled(event) {
+    let payload;
+    try {
+        payload = JSON.parse(event.payload);
+    }
+    catch (_a) {
+        // The binding was either called by something in the page or it was
+        // called before our wrapper was initialized.
+        return;
+    }
+    const { type, name, seq, args } = payload;
+    if (type !== 'exposedFun' || !__classPrivateFieldGet(this, _Page_pageBindings, "f").has(name)) {
+        return;
+    }
+    let expression = null;
+    try {
+        const pageBinding = __classPrivateFieldGet(this, _Page_pageBindings, "f").get(name);
+        (0, assert_1.assert)(pageBinding);
+        const result = await pageBinding(...args);
+        expression = (0, util_1.pageBindingDeliverResultString)(name, seq, result);
+    }
+    catch (_error) {
+        if ((0, util_1.isErrorLike)(_error)) {
+            expression = (0, util_1.pageBindingDeliverErrorString)(name, seq, _error.message, _error.stack);
+        }
+        else {
+            expression = (0, util_1.pageBindingDeliverErrorValueString)(name, seq, _error);
+        }
+    }
+    __classPrivateFieldGet(this, _Page_client, "f").send('Runtime.evaluate', {
+        expression,
+        contextId: event.executionContextId,
+    });
+}, _Page_addConsoleMessage = function _Page_addConsoleMessage(eventType, args, stackTrace) {
+    if (!this.listenerCount("console" /* PageEmittedEvents.Console */)) {
+        args.forEach((arg) => {
+            return arg.dispose();
+        });
+        return;
+    }
+    const textTokens = [];
+    for (const arg of args) {
+        const remoteObject = arg._remoteObject;
+        if (remoteObject.objectId) {
+            textTokens.push(arg.toString());
+        }
+        else {
+            textTokens.push((0, util_1.valueFromRemoteObject)(remoteObject));
+        }
+    }
+    const stackTraceLocations = [];
+    if (stackTrace) {
+        for (const callFrame of stackTrace.callFrames) {
+            stackTraceLocations.push({
+                url: callFrame.url,
+                lineNumber: callFrame.lineNumber,
+                columnNumber: callFrame.columnNumber,
+            });
+        }
+    }
+    const message = new ConsoleMessage_1.ConsoleMessage(eventType, textTokens.join(' '), args, stackTraceLocations);
+    this.emit("console" /* PageEmittedEvents.Console */, message);
+};

package/dist/browser/pkg-dir.d.ts

@@ -0,0 +1,3 @@
+export declare function packageDirectorySync({ cwd }?: {
+    cwd: any;
+}): any;

package/dist/browser/pkg-dir.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageDirectorySync = void 0;
+const find_up_1 = require("find-up");
+const path_1 = __importDefault(require("path"));
+function packageDirectorySync({ cwd } = {}) {
+    const filePath = (0, find_up_1.findUpSync)('package.json', { cwd });
+    return filePath && path_1.default.dirname(filePath);
+}
+exports.packageDirectorySync = packageDirectorySync;

package/dist/browser/revisions.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.
+ */
+declare type Revisions = Readonly<{
+    readonly chromium: string;
+    readonly firefox: string;
+}>;
+export declare const PUPPETEER_REVISIONS: Revisions;
+export {};

package/dist/browser/revisions.js

@@ -0,0 +1,22 @@
+"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.PUPPETEER_REVISIONS = void 0;
+exports.PUPPETEER_REVISIONS = {
+    chromium: '1002410',
+    firefox: 'latest',
+};

package/dist/browser/util.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+import type { Browser } from './Browser';
+import type { CDPSession } from './Connection';
+import type { DevtoolsRemoteObject, ExceptionDetails } from './devtools-types';
+import type { CommonEventEmitter } from './EventEmitter';
+export declare function getExceptionMessage(exceptionDetails: ExceptionDetails): string;
+export declare function valueFromRemoteObject(remoteObject: DevtoolsRemoteObject): any;
+export declare function releaseObject(client: CDPSession, remoteObject: DevtoolsRemoteObject): Promise<void>;
+export interface PuppeteerEventListener {
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}
+export declare function addEventListener(emitter: CommonEventEmitter, eventName: string | symbol, handler: (...args: any[]) => void): PuppeteerEventListener;
+export declare function removeEventListeners(listeners: Array<{
+    emitter: CommonEventEmitter;
+    eventName: string | symbol;
+    handler: (...args: any[]) => void;
+}>): void;
+export declare const isString: (obj: unknown) => obj is string;
+export declare function evaluationString(fun: Function | string, ...args: unknown[]): string;
+export declare function pageBindingDeliverResultString(name: string, seq: number, result: unknown): string;
+export declare function pageBindingDeliverErrorString(name: string, seq: number, message: string, stack?: string): string;
+export declare function pageBindingDeliverErrorValueString(name: string, seq: number, value: unknown): string;
+export declare function waitWithTimeout<T>(promise: Promise<T>, taskName: string, timeout: number, browser: Browser): Promise<T>;
+interface ErrorLike extends Error {
+    name: string;
+    message: string;
+}
+export declare function isErrorLike(obj: unknown): obj is ErrorLike;
+export declare function isErrnoException(obj: unknown): obj is NodeJS.ErrnoException;
+export {};

package/dist/browser/util.js

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

package/dist/browser-log.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser-log.d.ts","sourceRoot":"","sources":["../src/browser-log.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,sBAAsB,EAAE,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAE1E,oBAAY,UAAU,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,sBAAsB,EAAE,CAAC;IACrC,IAAI,EAAE,kBAAkB,CAAC;CACzB,CAAC"}

package/dist/browser-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-log.js","sourceRoot":"","sources":["../src/browser-log.ts"],"names":[],"mappings":""}

package/dist/calculate-ffmpeg-filters.d.ts

@@ -1,4 +1,4 @@
-import { MediaAsset } from './assets/types';
+import type { MediaAsset } from './assets/types';
 export declare const calculateFfmpegFilter: ({ asset, fps, durationInFrames, channels, assetDuration, }: {
     asset: MediaAsset;
     fps: number;

package/dist/calculate-ffmpeg-filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-ffmpeg-filters.d.ts","sourceRoot":"","sources":["../src/calculate-ffmpeg-filters.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,gBAAgB,CAAC;AAG1C,eAAO,MAAM,qBAAqB;WAO1B,UAAU;SACZ,MAAM;sBACO,MAAM;cACd,MAAM;mBACD,MAAM,GAAG,IAAI;MACzB,MAAM,GAAG,IAoBZ,CAAC"}

package/dist/calculate-ffmpeg-filters.js

@@ -7,8 +7,8 @@ const calculateFfmpegFilter = ({ asset, fps, durationInFrames, channels, assetDu
     if (channels === 0) {
         return null;
     }
-    const assetTrimLeft = asset.trimLeft / fps;
-    const assetTrimRight = (asset.trimLeft + asset.duration * asset.playbackRate) / fps;
+    const assetTrimLeft = (asset.trimLeft * asset.playbackRate) / fps;
+    const assetTrimRight = assetTrimLeft + (asset.duration * asset.playbackRate) / fps;
     return (0, stringify_ffmpeg_filter_1.stringifyFfmpegFilter)({
         channels,
         startInVideo: asset.startInVideo,

package/dist/calculate-ffmpeg-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-ffmpeg-filters.js","sourceRoot":"","sources":["../src/calculate-ffmpeg-filters.ts"],"names":[],"mappings":";;;AAAA,wEAAiE;AAEjE,uEAAgE;AAEzD,MAAM,qBAAqB,GAAG,CAAC,EACrC,KAAK,EACL,GAAG,EACH,gBAAgB,EAChB,QAAQ,EACR,aAAa,GAOb,EAAiB,EAAE;IACnB,IAAI,QAAQ,KAAK,CAAC,EAAE;QACnB,OAAO,IAAI,CAAC;KACZ;IAED,MAAM,aAAa,GAAG,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC;IAC3C,MAAM,cAAc,GACnB,CAAC,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,GAAG,CAAC;IAE9D,OAAO,IAAA,+CAAqB,EAAC;QAC5B,QAAQ;QACR,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,QAAQ,EAAE,aAAa;QACvB,SAAS,EAAE,cAAc;QACzB,MAAM,EAAE,IAAA,yCAAkB,EAAC,KAAK,CAAC,MAAM,CAAC;QACxC,GAAG;QACH,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,gBAAgB;QAChB,aAAa;KACb,CAAC,CAAC;AACJ,CAAC,CAAC;AAhCW,QAAA,qBAAqB,yBAgChC"}

package/dist/calculate-sar-dar-pixels.d.ts

@@ -0,0 +1,9 @@
+export declare const calculateDisplayVideoSize: ({ darX, darY, x, y, }: {
+    x: number;
+    y: number;
+    darX: number;
+    darY: number;
+}) => {
+    width: number;
+    height: number;
+};

package/dist/calculate-sar-dar-pixels.js

@@ -0,0 +1,19 @@
+"use strict";
+// https://superuser.com/questions/907933/correct-aspect-ratio-without-re-encoding-video-file
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDisplayVideoSize = void 0;
+const calculateDisplayVideoSize = ({ darX, darY, x, y, }) => {
+    // We know two equations:
+    //   newWidth / newHeight = darX / darY
+    // and:
+    //   x * y = (newWidth * newHeight)
+    // I solved it then on pen and paper and simplified the formula:
+    const dimensions = x * y;
+    const newWidth = Math.sqrt(dimensions * (darX / darY));
+    const newHeight = dimensions / newWidth;
+    return {
+        height: Math.round(newHeight),
+        width: Math.round(newWidth),
+    };
+};
+exports.calculateDisplayVideoSize = calculateDisplayVideoSize;

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

@@ -1,2 +1,2 @@
-import { Codec } from 'remotion';
+import type { Codec } from 'remotion';
 export declare const canUseParallelEncoding: (codec: Codec) => boolean;

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

@@ -0,0 +1 @@
+{"version":3,"file":"can-use-parallel-encoding.d.ts","sourceRoot":"","sources":["../src/can-use-parallel-encoding.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,EAAY,MAAM,UAAU,CAAC;AAE1C,eAAO,MAAM,sBAAsB,UAAW,KAAK,YAMlD,CAAC"}

package/dist/can-use-parallel-encoding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"can-use-parallel-encoding.js","sourceRoot":"","sources":["../src/can-use-parallel-encoding.ts"],"names":[],"mappings":";;;AAAA,uCAA0C;AAEnC,MAAM,sBAAsB,GAAG,CAAC,KAAY,EAAE,EAAE;IACtD,IAAI,oBAAS,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE;QAClC,OAAO,KAAK,CAAC;KACb;IAED,OAAO,KAAK,KAAK,MAAM,IAAI,KAAK,KAAK,UAAU,IAAI,KAAK,KAAK,MAAM,CAAC;AACrE,CAAC,CAAC;AANW,QAAA,sBAAsB,0BAMjC"}

package/dist/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../src/chunk.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,wBAAyB,MAAM,UAMhD,CAAC"}

package/dist/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../src/chunk.ts"],"names":[],"mappings":";;;AAAO,MAAM,KAAK,GAAG,CAAI,KAAU,EAAE,IAAY,EAAE,EAAE;IACpD,OAAO,KAAK,CAAC,MAAM,CAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE;QAC7C,OAAO,GAAG,GAAG,IAAI,KAAK,CAAC;YACtB,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;YAClB,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;IACvD,CAAC,EAAE,EAAE,CAAC,CAAC;AACR,CAAC,CAAC;AANW,QAAA,KAAK,SAMhB"}