@remotion/renderer 3.0.28 → 3.0.31

package/dist/browser/ws.d.ts

@@ -0,0 +1,287 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <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;
+}
+declare module 'ws' {
+    export = WebSocket;
+}
+export {};

package/dist/browser/ws.js

@@ -0,0 +1,21 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-shadow */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+/* eslint-disable no-redeclare */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable lines-between-class-members */
+/* eslint-disable no-dupe-class-members */
+// Type definitions for ws 8.5
+// Project: https://github.com/websockets/ws
+// Definitions by: Paul Loyd <https://github.com/loyd>
+//                 Margus Lamp <https://github.com/mlamp>
+//                 Philippe D'Alva <https://github.com/TitaneBoy>
+//                 reduckted <https://github.com/reduckted>
+//                 teidesu <https://github.com/teidesu>
+//                 Bartosz Wojtkowiak <https://github.com/wojtkowiak>
+//                 Kyle Hensel <https://github.com/k-yle>
+//                 Samuel Skeen <https://github.com/cwadrupldijjit>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="node" />
+const events_1 = require("events");

package/dist/cancel.d.ts

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

package/dist/cancel.js

@@ -0,0 +1,25 @@
+"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/codec-supports-media.d.ts

@@ -0,0 +1,7 @@
+import type { Codec } from 'remotion';
+declare type MediaSupport = {
+    video: boolean;
+    audio: boolean;
+};
+export declare const codecSupportsMedia: (codec: Codec) => MediaSupport;
+export {};

package/dist/codec-supports-media.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codecSupportsMedia = void 0;
+const support = {
+    'h264-mkv': {
+        audio: true,
+        video: true,
+    },
+    aac: {
+        audio: true,
+        video: false,
+    },
+    gif: {
+        video: true,
+        audio: false,
+    },
+    h264: {
+        video: true,
+        audio: true,
+    },
+    h265: {
+        video: true,
+        audio: true,
+    },
+    mp3: {
+        audio: true,
+        video: false,
+    },
+    prores: {
+        audio: true,
+        video: true,
+    },
+    vp8: {
+        audio: true,
+        video: true,
+    },
+    vp9: {
+        audio: true,
+        video: true,
+    },
+    wav: {
+        audio: true,
+        video: false,
+    },
+};
+const codecSupportsMedia = (codec) => {
+    return support[codec];
+};
+exports.codecSupportsMedia = codecSupportsMedia;

package/dist/ensure-faststart.d.ts

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

package/dist/ensure-faststart.js

@@ -0,0 +1,14 @@
+"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/ensure-presentation-timestamp.js

@@ -7,8 +7,26 @@ exports.ensurePresentationTimestamps = void 0;
 const execa_1 = __importDefault(require("execa"));
 const promises_1 = require("fs/promises");
 const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const guess_extension_for_media_1 = require("./guess-extension-for-media");
 const ensureFileHasPresentationTimestamp = {};
 let callbacks = [];
+const getTemporaryOutputName = async (src) => {
+    const parts = src.split(path_1.default.sep);
+    // If there is no file extension for the video, then we need to temporarily add an extension
+    const lastPart = parts[parts.length - 1];
+    const extraExtension = lastPart.includes('.')
+        ? null
+        : await (0, guess_extension_for_media_1.guessExtensionForVideo)(src);
+    return parts
+        .map((p, i) => {
+        if (i === parts.length - 1) {
+            return [`pts-${p}`, extraExtension].filter(remotion_1.Internals.truthy).join('.');
+        }
+        return p;
+    })
+        .join(path_1.default.sep);
+};
 const ensurePresentationTimestamps = async (src) => {
     if (ensureFileHasPresentationTimestamp[src] === 'encoding') {
         return new Promise((resolve) => {
@@ -22,15 +40,8 @@ const ensurePresentationTimestamps = async (src) => {
         return;
     }
     ensureFileHasPresentationTimestamp[src] = 'encoding';
-    const parts = src.split(path_1.default.sep);
-    const output = parts
-        .map((p, i) => {
-        if (i === parts.length - 1) {
-            return `pts-${p}`;
-        }
-        return p;
-    })
-        .join(path_1.default.sep);
+    // If there is no file extension for the video, then we need to tempoa
+    const output = await getTemporaryOutputName(src);
     await (0, execa_1.default)('ffmpeg', [
         '-i',
         src,

package/dist/error-handling/handle-javascript-exception.d.ts

@@ -1,4 +1,4 @@
-import type { Page } from '../browser/Page';
+import type { Page } from '../browser/BrowserPage';
 import type { SymbolicatedStackFrame } from '../symbolicate-stacktrace';
 export declare class ErrorWithStackFrame extends Error {
     symbolicatedStackFrames: SymbolicatedStackFrame[] | null;

package/dist/extract-frame-from-video.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { FfmpegExecutable, OffthreadVideoImageFormat } from 'remotion';
 import type { LastFrameOptions } from './last-frame-from-video-cache';
 export declare const getLastFrameOfVideo: (options: LastFrameOptions) => Promise<Buffer>;

package/dist/faststart/atom.d.ts

@@ -0,0 +1,35 @@
+/// <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;

package/dist/faststart/atom.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasSubatoms = exports.isQtAtom = exports.traverseAtoms = exports.recurseFlattenAtoms = exports.parseAtoms = exports.SizeKind = exports.MAX_FTYP_ATOM_SIZE = exports.ATOM_PREAMBLE_SIZE = exports.CO64_ATOM = exports.STCO_ATOM = exports.STBL_ATOM = exports.MINF_ATOM = exports.MDIA_ATOM = exports.TRAK_ATOM = exports.CMOV_ATOM = exports.UUID_ATOM = exports.FTYP_ATOM = exports.PICT_ATOM = exports.WIDE_ATOM = exports.SKIP_ATOM = exports.PNOT_ATOM = exports.MOOV_ATOM = exports.MDAT_ATOM = exports.JUNK_ATOM = exports.FREE_ATOM = void 0;
+/* eslint-disable no-bitwise */
+const util_1 = require("./util");
+exports.FREE_ATOM = (0, util_1.asciiToU32Be)('free');
+exports.JUNK_ATOM = (0, util_1.asciiToU32Be)('junk');
+exports.MDAT_ATOM = (0, util_1.asciiToU32Be)('mdat');
+exports.MOOV_ATOM = (0, util_1.asciiToU32Be)('moov');
+exports.PNOT_ATOM = (0, util_1.asciiToU32Be)('pnot');
+exports.SKIP_ATOM = (0, util_1.asciiToU32Be)('skip');
+exports.WIDE_ATOM = (0, util_1.asciiToU32Be)('wide');
+exports.PICT_ATOM = (0, util_1.asciiToU32Be)('PICT');
+exports.FTYP_ATOM = (0, util_1.asciiToU32Be)('ftyp');
+exports.UUID_ATOM = (0, util_1.asciiToU32Be)('uuid');
+exports.CMOV_ATOM = (0, util_1.asciiToU32Be)('cmov');
+exports.TRAK_ATOM = (0, util_1.asciiToU32Be)('trak');
+exports.MDIA_ATOM = (0, util_1.asciiToU32Be)('mdia');
+exports.MINF_ATOM = (0, util_1.asciiToU32Be)('minf');
+exports.STBL_ATOM = (0, util_1.asciiToU32Be)('stbl');
+exports.STCO_ATOM = (0, util_1.asciiToU32Be)('stco');
+exports.CO64_ATOM = (0, util_1.asciiToU32Be)('co64');
+exports.ATOM_PREAMBLE_SIZE = BigInt(8);
+exports.MAX_FTYP_ATOM_SIZE = BigInt(1048576);
+var SizeKind;
+(function (SizeKind) {
+    SizeKind[SizeKind["U32"] = 0] = "U32";
+    SizeKind[SizeKind["U64"] = 1] = "U64";
+})(SizeKind = exports.SizeKind || (exports.SizeKind = {}));
+function parseAtoms(infile, depth = 0, shallow = false) {
+    const atoms = [];
+    const cur = {
+        pos: BigInt(0),
+    };
+    const len = BigInt(infile.byteLength);
+    while (cur.pos < len) {
+        if (len - cur.pos < 8) {
+            break;
+        }
+        let fwd; // forward-seek counter
+        let atomSize = BigInt((0, util_1.readU32)(cur, infile));
+        const atomType = (0, util_1.readU32)(cur, infile);
+        let sizeKind = SizeKind.U32;
+        if (atomSize === BigInt(1)) {
+            // 64-bit atom size
+            atomSize = (0, util_1.readU64)(cur, infile);
+            if (atomSize > BigInt(Number.MAX_SAFE_INTEGER)) {
+                throw new Error(`"${atomType}" atom size is larger than MAX_SAFE_INTEGER!`);
+            }
+            fwd = atomSize - exports.ATOM_PREAMBLE_SIZE * BigInt(2);
+            sizeKind = SizeKind.U64;
+        }
+        else {
+            fwd = atomSize - exports.ATOM_PREAMBLE_SIZE;
+        }
+        const endOfAtom = cur.pos + fwd;
+        const subatoms = Buffer.from(infile.slice(Number(cur.pos), Number(endOfAtom)));
+        const data = hasSubatoms(atomType) && depth < 10 && !shallow
+            ? parseAtoms(subatoms, depth + 1)
+            : subatoms;
+        cur.pos = endOfAtom;
+        if (depth === 0 && !isQtAtom(atomType)) {
+            throw new Error(`Non-QT top-level atom found: ${(0, util_1.u32BeToAscii)(atomType)}`);
+        }
+        atoms.push({
+            kind: (0, util_1.u32BeToAscii)(atomType),
+            size: atomSize,
+            sizeKind,
+            data,
+        });
+    }
+    return atoms;
+}
+exports.parseAtoms = parseAtoms;
+function recurseFlattenAtoms(atoms, depth = 0) {
+    const buffers = [];
+    for (const atom of atoms) {
+        if (!Buffer.isBuffer(atom.data)) {
+            atom.data = recurseFlattenAtoms(atom.data, depth + 1);
+        }
+        let header;
+        const u64Size = Number(exports.ATOM_PREAMBLE_SIZE) + atom.data.byteLength > 2 ** 32 - 1;
+        if (u64Size) {
+            const u64Preamble = Number(exports.ATOM_PREAMBLE_SIZE) * 2;
+            header = Buffer.alloc(u64Preamble);
+            header.writeUInt32BE(1, 0);
+            header.writeUInt32BE((0, util_1.asciiToU32Be)(atom.kind), 4);
+            const newSize = u64Preamble + atom.data.byteLength;
+            header.writeUInt32BE((newSize >> 32) & 0xffffffff, 8);
+            header.writeUInt32BE(newSize & 0xffffffff, 12);
+        }
+        else {
+            header = Buffer.alloc(Number(exports.ATOM_PREAMBLE_SIZE));
+            const newSize = Number(exports.ATOM_PREAMBLE_SIZE) + atom.data.byteLength;
+            header.writeUInt32BE(newSize, 0);
+            header.writeUInt32BE((0, util_1.asciiToU32Be)(atom.kind), 4);
+        }
+        const buf = Buffer.concat([header, atom.data]);
+        buffers.push(buf);
+    }
+    return Buffer.concat(buffers);
+}
+exports.recurseFlattenAtoms = recurseFlattenAtoms;
+function traverseAtoms(atoms, callback) {
+    for (const atom of atoms) {
+        if (!Buffer.isBuffer(atom.data)) {
+            traverseAtoms(atom.data, callback);
+        }
+        callback(atom);
+    }
+}
+exports.traverseAtoms = traverseAtoms;
+function isQtAtom(atomType) {
+    return [
+        exports.FREE_ATOM,
+        exports.JUNK_ATOM,
+        exports.MDAT_ATOM,
+        exports.MOOV_ATOM,
+        exports.PNOT_ATOM,
+        exports.SKIP_ATOM,
+        exports.WIDE_ATOM,
+        exports.PICT_ATOM,
+        exports.FTYP_ATOM,
+        exports.UUID_ATOM,
+        exports.CMOV_ATOM,
+        exports.TRAK_ATOM,
+        exports.MDIA_ATOM,
+        exports.MINF_ATOM,
+        exports.STBL_ATOM,
+        exports.STCO_ATOM,
+        exports.CO64_ATOM,
+    ].includes(atomType);
+}
+exports.isQtAtom = isQtAtom;
+function hasSubatoms(atomType) {
+    return [exports.MOOV_ATOM, exports.TRAK_ATOM, exports.MDIA_ATOM, exports.MINF_ATOM, exports.STBL_ATOM].includes(atomType);
+}
+exports.hasSubatoms = hasSubatoms;

package/dist/faststart/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/faststart/options.d.ts

@@ -0,0 +1,6 @@
+export interface FaststartOptions {
+    /**
+     * Forces all `stco` atoms to be upgraded to `co64` atoms
+     */
+    forceUpgradeToCo64?: boolean;
+}