@remotion/serverless 4.0.188

package/dist/region.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWS_REGIONS = exports.DEFAULT_AWS_REGIONS = void 0;
+exports.DEFAULT_AWS_REGIONS = [
+    'eu-central-1',
+    'eu-west-1',
+    'eu-west-2',
+    'eu-west-3',
+    'eu-north-1',
+    'us-east-1', // N. Virginia
+    'us-east-2', // Ohio;
+    'us-west-1',
+    'us-west-2', // Oregon
+    'ap-south-1',
+    'ap-southeast-1',
+    'ap-southeast-2',
+    'ap-northeast-1',
+    'ap-northeast-2',
+    'ap-northeast-3',
+    'ca-central-1',
+    'sa-east-1',
+];
+exports.AWS_REGIONS = [
+    'eu-central-1',
+    'eu-west-1',
+    'eu-west-2',
+    'eu-west-3',
+    'eu-south-1',
+    'eu-north-1',
+    'us-east-1', // N. Virginia
+    'us-east-2', // Ohio;
+    'us-west-1',
+    'us-west-2', // Oregon
+    'af-south-1',
+    'ap-south-1',
+    'ap-east-1',
+    'ap-southeast-1',
+    'ap-southeast-2',
+    'ap-northeast-1',
+    'ap-northeast-2',
+    'ap-northeast-3',
+    'ca-central-1',
+    'me-south-1',
+    'sa-east-1',
+];

package/dist/render-metadata.d.ts

@@ -0,0 +1,37 @@
+import type { AudioCodec, DeleteAfter, StillImageFormat, VideoImageFormat } from '@remotion/renderer';
+import type { DownloadBehavior, OutNameInputWithoutCredentials, Privacy, SerializedInputProps, ServerlessCodec } from './constants';
+import type { CloudProvider } from './still';
+type Discriminated = {
+    type: 'still';
+    imageFormat: StillImageFormat;
+    codec: null;
+} | {
+    type: 'video';
+    imageFormat: VideoImageFormat;
+    muted: boolean;
+    frameRange: [number, number];
+    everyNthFrame: number;
+    codec: ServerlessCodec;
+};
+export type RenderMetadata<Provider extends CloudProvider> = Discriminated & {
+    siteId: string;
+    startedDate: number;
+    totalChunks: number;
+    estimatedTotalLambdaInvokations: number;
+    estimatedRenderLambdaInvokations: number;
+    compositionId: string;
+    audioCodec: AudioCodec | null;
+    inputProps: SerializedInputProps;
+    framesPerLambda: number;
+    memorySizeInMb: number;
+    lambdaVersion: string;
+    region: Provider['region'];
+    renderId: string;
+    outName: OutNameInputWithoutCredentials | undefined;
+    privacy: Privacy;
+    deleteAfter: DeleteAfter | null;
+    numberOfGifLoops: number | null;
+    audioBitrate: string | null;
+    downloadBehavior: DownloadBehavior;
+};
+export {};

package/dist/render-metadata.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/serialize-artifact.d.ts

@@ -0,0 +1,9 @@
+import type { EmittedArtifact } from '@remotion/renderer';
+export type SerializedArtifact = {
+    filename: string;
+    stringContent: string;
+    frame: number;
+    binary: boolean;
+};
+export declare const deserializeArtifact: (serializedArtifact: SerializedArtifact) => EmittedArtifact;
+export declare const serializeArtifact: (artifact: EmittedArtifact) => SerializedArtifact;

package/dist/serialize-artifact.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeArtifact = exports.deserializeArtifact = void 0;
+const deserializeArtifact = (serializedArtifact) => {
+    if (serializedArtifact.binary) {
+        const content = new TextEncoder().encode(atob(serializedArtifact.stringContent));
+        return {
+            filename: serializedArtifact.filename,
+            content,
+            frame: serializedArtifact.frame,
+        };
+    }
+    return {
+        filename: serializedArtifact.filename,
+        content: serializedArtifact.stringContent,
+        frame: serializedArtifact.frame,
+    };
+};
+exports.deserializeArtifact = deserializeArtifact;
+const serializeArtifact = (artifact) => {
+    if (artifact.content instanceof Uint8Array) {
+        const b64encoded = btoa(new TextDecoder('utf8').decode(artifact.content));
+        return {
+            filename: artifact.filename,
+            stringContent: b64encoded,
+            frame: artifact.frame,
+            binary: true,
+        };
+    }
+    return {
+        filename: artifact.filename,
+        stringContent: artifact.content,
+        frame: artifact.frame,
+        binary: false,
+    };
+};
+exports.serializeArtifact = serializeArtifact;

package/dist/still.d.ts

@@ -0,0 +1,28 @@
+export interface CloudProvider<Region extends string = string, ReceivedArtifactType extends Record<string, unknown> = Record<string, unknown>> {
+    type: string;
+    region: Region;
+    receivedArtifactType: ReceivedArtifactType;
+}
+export type ReceivedArtifact<Provider extends CloudProvider> = {
+    filename: string;
+    sizeInBytes: number;
+    s3Url: string;
+    s3Key: string;
+} & Provider['receivedArtifactType'];
+export type CostsInfo = {
+    accruedSoFar: number;
+    displayCost: string;
+    currency: string;
+    disclaimer: string;
+};
+export type RenderStillLambdaResponsePayload<Provider extends CloudProvider> = {
+    type: 'success';
+    output: string;
+    outKey: string;
+    size: number;
+    bucketName: string;
+    sizeInBytes: number;
+    estimatedPrice: CostsInfo;
+    renderId: string;
+    receivedArtifacts: ReceivedArtifact<Provider>[];
+};

package/dist/still.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/stream-to-string.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Readable } from 'stream';
+export declare function streamToString(stream: Readable | Buffer): string | Promise<string>;

package/dist/stream-to-string.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamToString = void 0;
+function streamToString(stream) {
+    if (Buffer.isBuffer(stream)) {
+        return stream.toString('utf-8');
+    }
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        stream.on('error', (err) => reject(err));
+        stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    });
+}
+exports.streamToString = streamToString;

package/dist/streaming/response-stream.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Writable } from 'stream';
+type Chunk = {
+    PayloadChunk: {
+        Payload: string | Buffer | null;
+    };
+    InvokeComplete: boolean;
+};
+export declare class ResponseStream extends Writable {
+    private queue;
+    private waitingResolve;
+    private response;
+    constructor();
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _finish(): void;
+    getBufferedData(): Buffer;
+    [Symbol.asyncIterator](): AsyncGenerator<Chunk, void, void>;
+}
+export {};

package/dist/streaming/response-stream.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseStream = void 0;
+const stream_1 = require("stream");
+class ResponseStream extends stream_1.Writable {
+    constructor() {
+        super();
+        this.queue = [];
+        this.waitingResolve = [];
+        this.response = [];
+    }
+    _write(chunk, encoding, callback) {
+        const data = Buffer.from(chunk, encoding);
+        const resolve = this.waitingResolve.shift();
+        if (resolve) {
+            resolve({ PayloadChunk: { Payload: data }, InvokeComplete: false });
+        }
+        else {
+            this.queue.push({ PayloadChunk: { Payload: data }, InvokeComplete: false });
+        }
+        this.response.push(Buffer.from(chunk, encoding));
+        callback();
+    }
+    _finish() {
+        const resolve = this.waitingResolve.shift();
+        if (resolve) {
+            resolve({ PayloadChunk: { Payload: null }, InvokeComplete: true });
+        }
+        else {
+            this.queue.push({ PayloadChunk: { Payload: null }, InvokeComplete: true });
+        }
+    }
+    getBufferedData() {
+        return Buffer.concat(this.response);
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                const shifted = this.queue.shift();
+                yield shifted;
+                if (shifted.InvokeComplete) {
+                    break;
+                }
+            }
+            else {
+                // Wait for new data to be written
+                const shifted = await new Promise((resolve) => {
+                    this.waitingResolve.push((data) => {
+                        Promise.resolve(data).then((d) => {
+                            if (d) {
+                                resolve(d);
+                            }
+                        });
+                    });
+                });
+                yield shifted;
+                if (shifted.InvokeComplete) {
+                    break;
+                }
+            }
+        }
+    }
+}
+exports.ResponseStream = ResponseStream;

package/dist/streaming/stream-writer.d.ts

@@ -0,0 +1,6 @@
+import type { ResponseStream } from './response-stream';
+export type ResponseStreamWriter = {
+    write: (message: Uint8Array) => Promise<void>;
+    end: () => Promise<void>;
+};
+export declare const streamWriter: (responseStream: ResponseStream) => ResponseStreamWriter;

package/dist/streaming/stream-writer.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamWriter = void 0;
+// Ensures that the previous write is finished before the next one is started
+// Genius solution by ChatGPT
+const streamWriter = (responseStream) => {
+    let promiseChain = Promise.resolve();
+    const write = (message) => {
+        promiseChain = promiseChain.then(() => {
+            return new Promise((resolve, reject) => {
+                responseStream.write(message, (err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            });
+        });
+        return promiseChain;
+    };
+    const end = () => {
+        promiseChain = promiseChain.then(() => {
+            return new Promise((resolve) => {
+                responseStream.end(() => {
+                    resolve();
+                });
+            });
+        });
+        return promiseChain;
+    };
+    return { write, end };
+};
+exports.streamWriter = streamWriter;

package/dist/streaming/streaming.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+import type { SerializedArtifact } from '../serialize-artifact';
+import type { CloudProvider, RenderStillLambdaResponsePayload } from '../still';
+import type { LambdaErrorInfo } from '../write-lambda-error';
+declare const framesRendered: "frames-rendered";
+declare const errorOccurred: "error-occurred";
+declare const renderIdDetermined: "render-id-determined";
+declare const videoChunkRendered: "video-chunk-rendered";
+declare const audioChunkRendered: "audio-chunk-rendered";
+declare const chunkComplete: "chunk-complete";
+declare const stillRendered: "still-rendered";
+declare const lambdaInvoked: "lambda-invoked";
+declare const artifactEmitted: "artifact-emitted";
+declare const messageTypes: {
+    readonly '1': {
+        readonly type: "frames-rendered";
+    };
+    readonly '2': {
+        readonly type: "error-occurred";
+    };
+    readonly '3': {
+        readonly type: "render-id-determined";
+    };
+    readonly '4': {
+        readonly type: "video-chunk-rendered";
+    };
+    readonly '5': {
+        readonly type: "audio-chunk-rendered";
+    };
+    readonly '6': {
+        readonly type: "still-rendered";
+    };
+    readonly '7': {
+        readonly type: "chunk-complete";
+    };
+    readonly '8': {
+        readonly type: "lambda-invoked";
+    };
+    readonly '9': {
+        readonly type: "artifact-emitted";
+    };
+};
+export type MessageTypeId = keyof typeof messageTypes;
+type MessageType = (typeof messageTypes)[MessageTypeId]['type'];
+export declare const formatMap: {
+    [key in MessageType]: 'json' | 'binary';
+};
+export type StreamingPayload<Provider extends CloudProvider> = {
+    type: typeof framesRendered;
+    payload: {
+        rendered: number;
+        encoded: number;
+    };
+} | {
+    type: typeof videoChunkRendered;
+    payload: Buffer;
+} | {
+    type: typeof audioChunkRendered;
+    payload: Buffer;
+} | {
+    type: typeof errorOccurred;
+    payload: {
+        error: string;
+        shouldRetry: boolean;
+        errorInfo: LambdaErrorInfo;
+    };
+} | {
+    type: typeof renderIdDetermined;
+    payload: {
+        renderId: string;
+    };
+} | {
+    type: typeof stillRendered;
+    payload: RenderStillLambdaResponsePayload<Provider>;
+} | {
+    type: typeof chunkComplete;
+    payload: {
+        start: number;
+        rendered: number;
+    };
+} | {
+    type: typeof lambdaInvoked;
+    payload: {
+        attempt: number;
+    };
+} | {
+    type: typeof artifactEmitted;
+    payload: {
+        artifact: SerializedArtifact;
+    };
+};
+export declare const messageTypeIdToMessageType: (messageTypeId: MessageTypeId) => MessageType;
+export type StreamingMessage<Provider extends CloudProvider> = {
+    successType: 'error' | 'success';
+    message: StreamingPayload<Provider>;
+};
+export type OnMessage<Provider extends CloudProvider> = (options: StreamingMessage<Provider>) => void;
+export type OnStream<Provider extends CloudProvider> = (payload: StreamingPayload<Provider>) => Promise<void>;
+export declare const makeStreamPayload: <Provider extends CloudProvider<string, Record<string, unknown>>>({ message, }: {
+    message: StreamingPayload<Provider>;
+}) => Uint8Array;
+export {};

package/dist/streaming/streaming.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStreamPayload = exports.messageTypeIdToMessageType = exports.formatMap = void 0;
+const streaming_1 = require("@remotion/streaming");
+const framesRendered = 'frames-rendered';
+const errorOccurred = 'error-occurred';
+const renderIdDetermined = 'render-id-determined';
+const videoChunkRendered = 'video-chunk-rendered';
+const audioChunkRendered = 'audio-chunk-rendered';
+const chunkComplete = 'chunk-complete';
+const stillRendered = 'still-rendered';
+const lambdaInvoked = 'lambda-invoked';
+const artifactEmitted = 'artifact-emitted';
+const messageTypes = {
+    '1': { type: framesRendered },
+    '2': { type: errorOccurred },
+    '3': { type: renderIdDetermined },
+    '4': { type: videoChunkRendered },
+    '5': { type: audioChunkRendered },
+    '6': { type: stillRendered },
+    '7': { type: chunkComplete },
+    '8': { type: lambdaInvoked },
+    '9': { type: artifactEmitted },
+};
+exports.formatMap = {
+    [framesRendered]: 'json',
+    [errorOccurred]: 'json',
+    [renderIdDetermined]: 'json',
+    [videoChunkRendered]: 'binary',
+    [audioChunkRendered]: 'binary',
+    [stillRendered]: 'json',
+    [chunkComplete]: 'json',
+    [lambdaInvoked]: 'json',
+    [artifactEmitted]: 'json',
+};
+const messageTypeIdToMessageType = (messageTypeId) => {
+    const types = messageTypes[messageTypeId];
+    if (!types) {
+        throw new Error(`Unknown message type id ${messageTypeId}`);
+    }
+    return types.type;
+};
+exports.messageTypeIdToMessageType = messageTypeIdToMessageType;
+const messageTypeToMessageId = (messageType) => {
+    const id = Object.keys(messageTypes).find((key) => messageTypes[key].type === messageType);
+    if (!id) {
+        throw new Error(`Unknown message type ${messageType}`);
+    }
+    return id;
+};
+const makeStreamPayload = ({ message, }) => {
+    const body = exports.formatMap[message.type] === 'json'
+        ? new TextEncoder().encode(JSON.stringify(message.payload))
+        : message.payload;
+    return (0, streaming_1.makeStreamPayloadMessage)({
+        body,
+        nonce: messageTypeToMessageId(message.type),
+        status: 0,
+    });
+};
+exports.makeStreamPayload = makeStreamPayload;

package/dist/truthy.d.ts

@@ -0,0 +1,3 @@
+type Truthy<T> = T extends false | '' | 0 | null | undefined ? never : T;
+export declare function truthy<T>(value: T): value is Truthy<T>;
+export {};

package/dist/truthy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truthy = void 0;
+function truthy(value) {
+    return Boolean(value);
+}
+exports.truthy = truthy;

package/dist/validate-bucket-name.d.ts

@@ -0,0 +1,3 @@
+export declare const validateBucketName: (bucketName: unknown, options: {
+    mustStartWithRemotion: boolean;
+}) => void;

package/dist/validate-bucket-name.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBucketName = void 0;
+const constants_1 = require("./constants");
+const validateBucketName = (bucketName, options) => {
+    if (typeof bucketName !== 'string') {
+        throw new TypeError(`'bucketName' must be a string, but is ${JSON.stringify(bucketName)}`);
+    }
+    if (options.mustStartWithRemotion &&
+        !bucketName.startsWith(constants_1.REMOTION_BUCKET_PREFIX)) {
+        throw new Error(`The bucketName parameter must start with ${constants_1.REMOTION_BUCKET_PREFIX}.`);
+    }
+    if (!bucketName.match(/^(?=^.{3,63}$)(?!^(\d+\.)+\d+$)(^(([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])\.)*([a-z0-9]|[a-z0-9][a-z0-9-]*[a-z0-9])$)/)) {
+        throw new Error(`The bucket ${bucketName} `);
+    }
+};
+exports.validateBucketName = validateBucketName;

package/dist/validate-composition.d.ts

@@ -0,0 +1,25 @@
+import type { ChromiumOptions, LogLevel, OnBrowserDownload, openBrowser, RemotionServer } from '@remotion/renderer';
+import type { VideoConfig } from 'remotion/no-react';
+import type { Await } from './await';
+import type { ProviderSpecifics } from './provider-implementation';
+import type { CloudProvider } from './still';
+type ValidateCompositionOptions<Provider extends CloudProvider> = {
+    serveUrl: string;
+    composition: string;
+    browserInstance: Await<ReturnType<typeof openBrowser>>;
+    serializedInputPropsWithCustomSchema: string;
+    envVariables: Record<string, string>;
+    timeoutInMilliseconds: number;
+    chromiumOptions: ChromiumOptions;
+    port: number | null;
+    forceHeight: number | null;
+    forceWidth: number | null;
+    logLevel: LogLevel;
+    server: RemotionServer | undefined;
+    offthreadVideoCacheSizeInBytes: number | null;
+    onBrowserDownload: OnBrowserDownload;
+    onServeUrlVisited: () => void;
+    providerSpecifics: ProviderSpecifics<Provider>;
+};
+export declare const validateComposition: <Provider extends CloudProvider<string, Record<string, unknown>>>({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, providerSpecifics, }: ValidateCompositionOptions<Provider>) => Promise<VideoConfig>;
+export {};

package/dist/validate-composition.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateComposition = void 0;
+const renderer_1 = require("@remotion/renderer");
+const validateComposition = async ({ serveUrl, composition, browserInstance, serializedInputPropsWithCustomSchema, envVariables, timeoutInMilliseconds, chromiumOptions, port, forceHeight, forceWidth, logLevel, server, offthreadVideoCacheSizeInBytes, onBrowserDownload, onServeUrlVisited, providerSpecifics, }) => {
+    const { metadata: comp } = await renderer_1.RenderInternals.internalSelectComposition({
+        id: composition,
+        puppeteerInstance: browserInstance,
+        serializedInputPropsWithCustomSchema,
+        envVariables,
+        timeoutInMilliseconds,
+        chromiumOptions,
+        port,
+        browserExecutable: providerSpecifics.getChromiumPath(),
+        serveUrl,
+        logLevel,
+        indent: false,
+        onBrowserLog: null,
+        server,
+        offthreadVideoCacheSizeInBytes,
+        binariesDirectory: null,
+        onBrowserDownload,
+        onServeUrlVisited,
+    });
+    return {
+        ...comp,
+        height: forceHeight !== null && forceHeight !== void 0 ? forceHeight : comp.height,
+        width: forceWidth !== null && forceWidth !== void 0 ? forceWidth : comp.width,
+    };
+};
+exports.validateComposition = validateComposition;

package/dist/validate-outname.d.ts

@@ -0,0 +1,8 @@
+import type { AudioCodec, Codec } from '@remotion/renderer';
+import type { OutNameInputWithoutCredentials } from './constants';
+export declare const validateOutname: ({ outName, codec, audioCodecSetting, separateAudioTo, }: {
+    outName: OutNameInputWithoutCredentials | undefined | null;
+    codec: Codec | null;
+    audioCodecSetting: AudioCodec | null;
+    separateAudioTo: string | null;
+}) => void;

package/dist/validate-outname.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOutname = void 0;
+const pure_1 = require("@remotion/renderer/pure");
+const validate_bucket_name_1 = require("./validate-bucket-name");
+const validateS3Key = (s3Key) => {
+    if (typeof s3Key !== 'string') {
+        throw new TypeError('The S3 key must be a string. Passed an object of type ' + typeof s3Key);
+    }
+    // https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html
+    if (!s3Key.match(/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g)) {
+        throw new Error("The S3 Key must match the RegExp `/^([0-9a-zA-Z-!_.*'()/:&$@=;+,?]+)/g`. You passed: " +
+            s3Key +
+            '. Check for invalid characters.');
+    }
+};
+const validateOutname = ({ outName, codec, audioCodecSetting, separateAudioTo, }) => {
+    if (typeof outName === 'undefined' || outName === null) {
+        return;
+    }
+    if (typeof outName !== 'string') {
+        validateS3Key(outName.key);
+        (0, validate_bucket_name_1.validateBucketName)(outName.bucketName, { mustStartWithRemotion: false });
+        return;
+    }
+    if (codec) {
+        pure_1.NoReactAPIs.validateOutputFilename({
+            codec,
+            audioCodecSetting,
+            extension: pure_1.NoReactAPIs.getExtensionOfFilename(outName),
+            preferLossless: false,
+            separateAudioTo,
+        });
+    }
+    validateS3Key(outName);
+};
+exports.validateOutname = validateOutname;

package/dist/validate-webhook.d.ts

@@ -0,0 +1,3 @@
+import type { WebhookOption } from './constants';
+export declare const MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+export declare const validateWebhook: (webhook?: WebhookOption | null) => void;

package/dist/validate-webhook.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWebhook = exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = void 0;
+exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE = 1024;
+const validateWebhook = (webhook) => {
+    if (typeof webhook === 'undefined' || webhook === null) {
+        return;
+    }
+    if (webhook.customData) {
+        const size = JSON.stringify(webhook.customData).length;
+        if (size > exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE) {
+            throw new Error(`Webhook "customData" must be less than ${exports.MAX_WEBHOOK_CUSTOM_DATA_SIZE} bytes. Current size: ${size} bytes.`);
+        }
+    }
+};
+exports.validateWebhook = validateWebhook;