@remotion/renderer 3.0.26 → 3.0.29

package/dist/ws/ws-types.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ws = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// @ts-expect-error
+const ws_1 = __importDefault(require("ws"));
+exports.ws = ws_1.default;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remotion/renderer",
-	"version": "3.0.26",
+	"version": "3.0.29",
 	"description": "Renderer for Remotion",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -22,8 +22,7 @@
 	"dependencies": {
 		"execa": "5.1.1",
 		"extract-zip": "2.0.1",
-		"mime-types": "2.1.35",
-		"remotion": "3.0.26",
+		"remotion": "3.0.29",
 		"source-map": "^0.8.0-beta.0",
 		"ws": "8.7.0"
 	},
@@ -36,13 +35,10 @@
 		"@testing-library/dom": "^8.7.2",
 		"@testing-library/react": "13.1.1",
 		"@types/jest": "^27.4.0",
-		"@types/mime-types": "2.1.1",
 		"@types/node": "^16.7.5",
 		"@types/progress": "2.0.5",
 		"@types/react": "18.0.1",
 		"@types/react-dom": "18.0.0",
-		"@types/ws": "8.5.3",
-		"devtools-protocol": "0.0.1001819",
 		"eslint": "8.13.0",
 		"jest": "^27.2.4",
 		"prettier": "^2.0.5",
@@ -63,5 +59,5 @@
 	"publishConfig": {
 		"access": "public"
 	},
-	"gitHead": "790e9bb2d66f2fe97efc209237cc57d7cad2e793"
+	"gitHead": "da2e8a33766bf01b21dfd3c2d0c944356d156722"
 }

package/tsconfig.json

@@ -5,6 +5,5 @@
 		"rootDir": "src",
 		"outDir": "dist"
 	},
-	"include": ["src"],
 	"references": [{"path": "../core"}, {"path": "../bundler"}]
 }

package/types/ws/index.d.ts

@@ -0,0 +1,509 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable lines-between-class-members */
+/* eslint-disable no-redeclare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable no-dupe-class-members */
+/// <reference types="node" />
+
+import {EventEmitter} from 'events';
+import type {
+	Agent,
+	ClientRequest,
+	ClientRequestArgs,
+	IncomingMessage,
+	OutgoingHttpHeaders,
+	Server as HTTPServer,
+} from 'http';
+import type {Server as HTTPSServer} from 'https';
+import type {Duplex, DuplexOptions} from 'stream';
+import type {SecureContextOptions} from 'tls';
+import type {URL} from 'url';
+import type {ZlibOptions} from 'zlib';
+declare class WebSocket extends EventEmitter {
+	/** The connection is not yet open. */
+	static readonly CONNECTING: 0;
+	/** The connection is open and ready to communicate. */
+	static readonly OPEN: 1;
+	/** The connection is in the process of closing. */
+	static readonly CLOSING: 2;
+	/** The connection is closed. */
+	static readonly CLOSED: 3;
+	binaryType: 'nodebuffer' | 'arraybuffer' | 'fragments';
+	readonly bufferedAmount: number;
+	readonly extensions: string;
+	/** Indicates whether the websocket is paused */
+	readonly isPaused: boolean;
+	readonly protocol: string;
+	/** The current state of the connection */
+	readonly readyState:
+		| typeof WebSocket.CONNECTING
+		| typeof WebSocket.OPEN
+		| typeof WebSocket.CLOSING
+		| typeof WebSocket.CLOSED;
+	readonly url: string;
+	/** The connection is not yet open. */
+	readonly CONNECTING: 0;
+	/** The connection is open and ready to communicate. */
+	readonly OPEN: 1;
+	/** The connection is in the process of closing. */
+	readonly CLOSING: 2;
+	/** The connection is closed. */
+	readonly CLOSED: 3;
+	onopen: ((event: WebSocket.Event) => void) | null;
+	onerror: ((event: WebSocket.ErrorEvent) => void) | null;
+	onclose: ((event: WebSocket.CloseEvent) => void) | null;
+	onmessage: ((event: WebSocket.MessageEvent) => void) | null;
+	constructor(address: null);
+	constructor(
+		address: string | URL,
+		options?: WebSocket.ClientOptions | ClientRequestArgs
+	);
+	constructor(
+		address: string | URL,
+		protocols?: string | string[],
+		options?: WebSocket.ClientOptions | ClientRequestArgs
+	);
+	close(code?: number, data?: string | Buffer): void;
+	ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+	pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void;
+	send(data: any, cb?: (err?: Error) => void): void;
+	send(
+		data: any,
+		options: {
+			mask?: boolean | undefined;
+			binary?: boolean | undefined;
+			compress?: boolean | undefined;
+			fin?: boolean | undefined;
+		},
+		cb?: (err?: Error) => void
+	): void;
+	terminate(): void;
+	/**
+	 * Pause the websocket causing it to stop emitting events. Some events can still be
+	 * emitted after this is called, until all buffered data is consumed. This method
+	 * is a noop if the ready state is `CONNECTING` or `CLOSED`.
+	 */
+	pause(): void;
+	/**
+	 * Make a paused socket resume emitting events. This method is a noop if the ready
+	 * state is `CONNECTING` or `CLOSED`.
+	 */
+	resume(): void;
+	addEventListener(
+		method: 'message',
+		cb: (event: WebSocket.MessageEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'close',
+		cb: (event: WebSocket.CloseEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'error',
+		cb: (event: WebSocket.ErrorEvent) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	addEventListener(
+		method: 'open',
+		cb: (event: WebSocket.Event) => void,
+		options?: WebSocket.EventListenerOptions
+	): void;
+	removeEventListener(
+		method: 'message',
+		cb: (event: WebSocket.MessageEvent) => void
+	): void;
+	removeEventListener(
+		method: 'close',
+		cb: (event: WebSocket.CloseEvent) => void
+	): void;
+	removeEventListener(
+		method: 'error',
+		cb: (event: WebSocket.ErrorEvent) => void
+	): void;
+	removeEventListener(
+		method: 'open',
+		cb: (event: WebSocket.Event) => void
+	): void;
+	on(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	on(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	on(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	on(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	on(event: 'open', listener: (this: WebSocket) => void): this;
+	on(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	on(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	on(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	once(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	once(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	once(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	once(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	once(event: 'open', listener: (this: WebSocket) => void): this;
+	once(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	once(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	once(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	off(
+		event: 'close',
+		listener: (this: WebSocket, code: number, reason: Buffer) => void
+	): this;
+	off(event: 'error', listener: (this: WebSocket, err: Error) => void): this;
+	off(
+		event: 'upgrade',
+		listener: (this: WebSocket, request: IncomingMessage) => void
+	): this;
+	off(
+		event: 'message',
+		listener: (
+			this: WebSocket,
+			data: WebSocket.RawData,
+			isBinary: boolean
+		) => void
+	): this;
+	off(event: 'open', listener: (this: WebSocket) => void): this;
+	off(
+		event: 'ping' | 'pong',
+		listener: (this: WebSocket, data: Buffer) => void
+	): this;
+	off(
+		event: 'unexpected-response',
+		listener: (
+			this: WebSocket,
+			request: ClientRequest,
+			response: IncomingMessage
+		) => void
+	): this;
+	off(
+		event: string | symbol,
+		listener: (this: WebSocket, ...args: any[]) => void
+	): this;
+	addListener(
+		event: 'close',
+		listener: (code: number, reason: Buffer) => void
+	): this;
+	addListener(event: 'error', listener: (err: Error) => void): this;
+	addListener(
+		event: 'upgrade',
+		listener: (request: IncomingMessage) => void
+	): this;
+	addListener(
+		event: 'message',
+		listener: (data: WebSocket.RawData, isBinary: boolean) => void
+	): this;
+	addListener(event: 'open', listener: () => void): this;
+	addListener(event: 'ping' | 'pong', listener: (data: Buffer) => void): this;
+	addListener(
+		event: 'unexpected-response',
+		listener: (request: ClientRequest, response: IncomingMessage) => void
+	): this;
+	addListener(event: string | symbol, listener: (...args: any[]) => void): this;
+	removeListener(
+		event: 'close',
+		listener: (code: number, reason: Buffer) => void
+	): this;
+	removeListener(event: 'error', listener: (err: Error) => void): this;
+	removeListener(
+		event: 'upgrade',
+		listener: (request: IncomingMessage) => void
+	): this;
+	removeListener(
+		event: 'message',
+		listener: (data: WebSocket.RawData, isBinary: boolean) => void
+	): this;
+	removeListener(event: 'open', listener: () => void): this;
+	removeListener(
+		event: 'ping' | 'pong',
+		listener: (data: Buffer) => void
+	): this;
+	removeListener(
+		event: 'unexpected-response',
+		listener: (request: ClientRequest, response: IncomingMessage) => void
+	): this;
+	removeListener(
+		event: string | symbol,
+		listener: (...args: any[]) => void
+	): this;
+}
+declare const WebSocketAlias: typeof WebSocket;
+declare type WebSocketAlias = WebSocket;
+declare namespace WebSocket {
+	/**
+	 * Data represents the raw message payload received over the WebSocket.
+	 */
+	type RawData = Buffer | ArrayBuffer | Buffer[];
+	/**
+	 * Data represents the message payload received over the WebSocket.
+	 */
+	type Data = string | Buffer | ArrayBuffer | Buffer[];
+	/**
+	 * CertMeta represents the accepted types for certificate & key data.
+	 */
+	type CertMeta = string | string[] | Buffer | Buffer[];
+	/**
+	 * VerifyClientCallbackSync is a synchronous callback used to inspect the
+	 * incoming message. The return value (boolean) of the function determines
+	 * whether or not to accept the handshake.
+	 */
+	type VerifyClientCallbackSync = (info: {
+		origin: string;
+		secure: boolean;
+		req: IncomingMessage;
+	}) => boolean;
+	/**
+	 * VerifyClientCallbackAsync is an asynchronous callback used to inspect the
+	 * incoming message. The return value (boolean) of the function determines
+	 * whether or not to accept the handshake.
+	 */
+	type VerifyClientCallbackAsync = (
+		info: {
+			origin: string;
+			secure: boolean;
+			req: IncomingMessage;
+		},
+		callback: (
+			res: boolean,
+			code?: number,
+			message?: string,
+			headers?: OutgoingHttpHeaders
+		) => void
+	) => void;
+	interface ClientOptions extends SecureContextOptions {
+		protocol?: string | undefined;
+		followRedirects?: boolean | undefined;
+		generateMask?(mask: Buffer): void;
+		handshakeTimeout?: number | undefined;
+		maxRedirects?: number | undefined;
+		perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+		localAddress?: string | undefined;
+		protocolVersion?: number | undefined;
+		headers?:
+			| {
+					[key: string]: string;
+			  }
+			| undefined;
+		origin?: string | undefined;
+		agent?: Agent | undefined;
+		host?: string | undefined;
+		family?: number | undefined;
+		checkServerIdentity?(servername: string, cert: CertMeta): boolean;
+		rejectUnauthorized?: boolean | undefined;
+		maxPayload?: number | undefined;
+		skipUTF8Validation?: boolean | undefined;
+	}
+	interface PerMessageDeflateOptions {
+		serverNoContextTakeover?: boolean | undefined;
+		clientNoContextTakeover?: boolean | undefined;
+		serverMaxWindowBits?: number | undefined;
+		clientMaxWindowBits?: number | undefined;
+		zlibDeflateOptions?:
+			| {
+					flush?: number | undefined;
+					finishFlush?: number | undefined;
+					chunkSize?: number | undefined;
+					windowBits?: number | undefined;
+					level?: number | undefined;
+					memLevel?: number | undefined;
+					strategy?: number | undefined;
+					dictionary?: Buffer | Buffer[] | DataView | undefined;
+					info?: boolean | undefined;
+			  }
+			| undefined;
+		zlibInflateOptions?: ZlibOptions | undefined;
+		threshold?: number | undefined;
+		concurrencyLimit?: number | undefined;
+	}
+	interface Event {
+		type: string;
+		target: WebSocket;
+	}
+	interface ErrorEvent {
+		error: any;
+		message: string;
+		type: string;
+		target: WebSocket;
+	}
+	interface CloseEvent {
+		wasClean: boolean;
+		code: number;
+		reason: string;
+		type: string;
+		target: WebSocket;
+	}
+	interface MessageEvent {
+		data: Data;
+		type: string;
+		target: WebSocket;
+	}
+	interface EventListenerOptions {
+		once?: boolean | undefined;
+	}
+	interface ServerOptions {
+		host?: string | undefined;
+		port?: number | undefined;
+		backlog?: number | undefined;
+		server?: HTTPServer | HTTPSServer | undefined;
+		verifyClient?:
+			| VerifyClientCallbackAsync
+			| VerifyClientCallbackSync
+			| undefined;
+		handleProtocols?: (
+			protocols: Set<string>,
+			request: IncomingMessage
+		) => string | false;
+		path?: string | undefined;
+		noServer?: boolean | undefined;
+		clientTracking?: boolean | undefined;
+		perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined;
+		maxPayload?: number | undefined;
+		skipUTF8Validation?: boolean | undefined;
+		WebSocket?: typeof WebSocket.WebSocket | undefined;
+	}
+	interface AddressInfo {
+		address: string;
+		family: string;
+		port: number;
+	}
+	class Server<T extends WebSocket = WebSocket> extends EventEmitter {
+		options: ServerOptions;
+		path: string;
+		clients: Set<T>;
+		constructor(options?: ServerOptions, callback?: () => void);
+		address(): AddressInfo | string;
+		close(cb?: (err?: Error) => void): void;
+		handleUpgrade(
+			request: IncomingMessage,
+			socket: Duplex,
+			upgradeHead: Buffer,
+			callback: (client: T, request: IncomingMessage) => void
+		): void;
+		shouldHandle(request: IncomingMessage): boolean | Promise<boolean>;
+		on(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		on(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		on(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		on(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		on(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		once(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		once(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		once(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		once(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		once(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		off(
+			event: 'connection',
+			cb: (this: Server<T>, socket: T, request: IncomingMessage) => void
+		): this;
+		off(event: 'error', cb: (this: Server<T>, error: Error) => void): this;
+		off(
+			event: 'headers',
+			cb: (this: Server<T>, headers: string[], request: IncomingMessage) => void
+		): this;
+		off(event: 'close' | 'listening', cb: (this: Server<T>) => void): this;
+		off(
+			event: string | symbol,
+			listener: (this: Server<T>, ...args: any[]) => void
+		): this;
+		addListener(
+			event: 'connection',
+			cb: (client: T, request: IncomingMessage) => void
+		): this;
+		addListener(event: 'error', cb: (err: Error) => void): this;
+		addListener(
+			event: 'headers',
+			cb: (headers: string[], request: IncomingMessage) => void
+		): this;
+		addListener(event: 'close' | 'listening', cb: () => void): this;
+		addListener(
+			event: string | symbol,
+			listener: (...args: any[]) => void
+		): this;
+		removeListener(event: 'connection', cb: (client: T) => void): this;
+		removeListener(event: 'error', cb: (err: Error) => void): this;
+		removeListener(
+			event: 'headers',
+			cb: (headers: string[], request: IncomingMessage) => void
+		): this;
+		removeListener(event: 'close' | 'listening', cb: () => void): this;
+		removeListener(
+			event: string | symbol,
+			listener: (...args: any[]) => void
+		): this;
+	}
+	const WebSocketServer: typeof Server;
+	interface WebSocketServer extends Server {}
+	const WebSocket: typeof WebSocketAlias;
+	interface WebSocket extends WebSocketAlias {}
+	function createWebSocketStream(
+		websocket: WebSocket,
+		options?: DuplexOptions
+	): Duplex;
+}
+
+export = WebSocket;

package/dist/abort.d.ts

@@ -1,7 +0,0 @@
-declare type Callback = () => void;
-export declare type CancelSignal = (callback: Callback) => void;
-export declare const getCancelSignal: () => {
-    cancelSignal: CancelSignal;
-    cancel: () => void;
-};
-export {};

package/dist/abort.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCancelSignal = void 0;
-const getCancelSignal = () => {
-    const callbacks = [];
-    let cancelled = false;
-    return {
-        cancelSignal: (callback) => callbacks.push(callback),
-        cancel: () => {
-            if (cancelled) {
-                return;
-            }
-            callbacks.forEach((cb) => {
-                cb();
-            });
-            cancelled = true;
-        },
-    };
-};
-exports.getCancelSignal = getCancelSignal;

package/dist/cancel.d.ts

@@ -1,7 +0,0 @@
-declare type Callback = () => void;
-export declare type CancelSignal = (callback: Callback) => void;
-export declare const makeCancelSignal: () => {
-    cancelSignal: CancelSignal;
-    cancel: () => void;
-};
-export {};

package/dist/cancel.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeCancelSignal = void 0;
-const makeCancelSignal = () => {
-    const callbacks = [];
-    let cancelled = false;
-    return {
-        cancelSignal: (callback) => {
-            callbacks.push(callback);
-            if (cancelled) {
-                callback();
-            }
-        },
-        cancel: () => {
-            if (cancelled) {
-                return;
-            }
-            callbacks.forEach((cb) => {
-                cb();
-            });
-            cancelled = true;
-        },
-    };
-};
-exports.makeCancelSignal = makeCancelSignal;

package/dist/ensure-faststart.d.ts

@@ -1 +0,0 @@
-export declare const ensureFastStart: () => void;

package/dist/ensure-faststart.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureFastStart = void 0;
-const fs_1 = require("fs");
-const qt_faststart_1 = __importDefault(require("./faststart/qt-faststart"));
-const ensureFastStart = () => {
-    const buffer = (0, fs_1.readFileSync)('/Users/jonathanburger/remotion/packages/example/public/offthread2.mp4');
-    const newBuffer = (0, qt_faststart_1.default)(buffer);
-    (0, fs_1.writeFileSync)('/Users/jonathanburger/remotion/packages/example/public/offthread-faststart.mp4', newBuffer);
-};
-exports.ensureFastStart = ensureFastStart;

package/dist/faststart/atom.d.ts

@@ -1,35 +0,0 @@
-/// <reference types="node" />
-export declare const FREE_ATOM: number;
-export declare const JUNK_ATOM: number;
-export declare const MDAT_ATOM: number;
-export declare const MOOV_ATOM: number;
-export declare const PNOT_ATOM: number;
-export declare const SKIP_ATOM: number;
-export declare const WIDE_ATOM: number;
-export declare const PICT_ATOM: number;
-export declare const FTYP_ATOM: number;
-export declare const UUID_ATOM: number;
-export declare const CMOV_ATOM: number;
-export declare const TRAK_ATOM: number;
-export declare const MDIA_ATOM: number;
-export declare const MINF_ATOM: number;
-export declare const STBL_ATOM: number;
-export declare const STCO_ATOM: number;
-export declare const CO64_ATOM: number;
-export declare const ATOM_PREAMBLE_SIZE: bigint;
-export declare const MAX_FTYP_ATOM_SIZE: bigint;
-export declare enum SizeKind {
-    U32 = 0,
-    U64 = 1
-}
-export interface QtAtom {
-    kind: string;
-    size: BigInt;
-    sizeKind: SizeKind;
-    data: QtAtom[] | Buffer;
-}
-export declare function parseAtoms(infile: Buffer, depth?: number, shallow?: boolean): QtAtom[];
-export declare function recurseFlattenAtoms(atoms: QtAtom[], depth?: number): Buffer;
-export declare function traverseAtoms(atoms: QtAtom[], callback: (atom: QtAtom) => void): void;
-export declare function isQtAtom(atomType: number): boolean;
-export declare function hasSubatoms(atomType: number): boolean;