@remotion/media-parser 4.0.269 → 4.0.271

package/dist/worker-server.js

@@ -0,0 +1,381 @@
+import { defaultSelectM3uAssociatedPlaylists, defaultSelectM3uStreamFn, } from './containers/m3u/select-stream';
+import { internalParseMedia } from './internal-parse-media';
+import { mediaParserController } from './media-parser-controller';
+import { forwardMediaParserControllerToWorker } from './worker/forward-controller';
+import { serializeError } from './worker/serialize-error';
+const post = (message) => {
+    postMessage(message);
+};
+const controller = mediaParserController();
+const executeCallback = (payload) => {
+    const nonce = crypto.randomUUID();
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const cb = (msg) => {
+        const data = msg.data;
+        if (data.type === 'acknowledge-callback' && data.nonce === nonce) {
+            const { nonce: _, ...pay } = data;
+            controller._internals
+                .checkForAbortAndPause()
+                .then(() => {
+                resolve(pay);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+            removeEventListener('message', cb);
+        }
+        if (data.type === 'signal-error-in-callback') {
+            reject(new Error('Error in callback function'));
+        }
+    };
+    addEventListener('message', cb);
+    post({
+        type: 'response-on-callback-request',
+        payload,
+        nonce,
+    });
+    return promise;
+};
+const startParsing = async (message, reader) => {
+    const { payload, src } = message;
+    const { fields, acknowledgeRemotionLicense, logLevel: userLogLevel, progressIntervalInMs, mp4HeaderSegment, } = payload;
+    const { postAudioCodec, postContainer, postDimensions, postFps, postImages, postInternalStats, postIsHdr, postKeyframes, postLocation, postM3uStreams, postMetadata, postMimeType, postName, postNumberOfAudioChannels, postRotation, postSampleRate, postSlowAudioBitrate, postSlowNumberOfFrames, postSlowFps, postSlowDurationInSeconds, postSlowVideoBitrate, postStructure, postTracks, postUnrotatedDimensions, postVideoCodec, postSize, postSlowKeyframes, postDurationInSeconds, postParseProgress, postM3uStreamSelection, postM3uAssociatedPlaylistsSelection, postOnAudioTrack, postOnVideoTrack, } = message;
+    const logLevel = userLogLevel !== null && userLogLevel !== void 0 ? userLogLevel : 'info';
+    try {
+        const ret = await internalParseMedia({
+            src,
+            reader,
+            acknowledgeRemotionLicense: Boolean(acknowledgeRemotionLicense),
+            onError: () => ({ action: 'fail' }),
+            logLevel,
+            fields: fields !== null && fields !== void 0 ? fields : null,
+            apiName: 'parseMediaInWorker()',
+            controller,
+            mode: 'query',
+            onAudioCodec: postAudioCodec
+                ? async (codec) => {
+                    await executeCallback({
+                        callbackType: 'audio-codec',
+                        value: codec,
+                    });
+                }
+                : null,
+            onContainer: postContainer
+                ? async (container) => {
+                    await executeCallback({
+                        callbackType: 'container',
+                        value: container,
+                    });
+                }
+                : null,
+            onDimensions: postDimensions
+                ? async (dimensions) => {
+                    await executeCallback({
+                        callbackType: 'dimensions',
+                        value: dimensions,
+                    });
+                }
+                : null,
+            onFps: postFps
+                ? async (fps) => {
+                    await executeCallback({
+                        callbackType: 'fps',
+                        value: fps,
+                    });
+                }
+                : null,
+            onImages: postImages
+                ? async (images) => {
+                    await executeCallback({
+                        callbackType: 'images',
+                        value: images,
+                    });
+                }
+                : null,
+            onInternalStats: postInternalStats
+                ? async (internalStats) => {
+                    await executeCallback({
+                        callbackType: 'internal-stats',
+                        value: internalStats,
+                    });
+                }
+                : null,
+            onIsHdr: postIsHdr
+                ? async (isHdr) => {
+                    await executeCallback({
+                        callbackType: 'is-hdr',
+                        value: isHdr,
+                    });
+                }
+                : null,
+            onKeyframes: postKeyframes
+                ? async (keyframes) => {
+                    await executeCallback({
+                        callbackType: 'keyframes',
+                        value: keyframes,
+                    });
+                }
+                : null,
+            onLocation: postLocation
+                ? async (location) => {
+                    await executeCallback({
+                        callbackType: 'location',
+                        value: location,
+                    });
+                }
+                : null,
+            onM3uStreams: postM3uStreams
+                ? async (streams) => {
+                    await executeCallback({
+                        callbackType: 'm3u-streams',
+                        value: streams,
+                    });
+                }
+                : null,
+            onMetadata: postMetadata
+                ? async (metadata) => {
+                    await executeCallback({
+                        callbackType: 'metadata',
+                        value: metadata,
+                    });
+                }
+                : null,
+            onMimeType: postMimeType
+                ? async (mimeType) => {
+                    await executeCallback({
+                        callbackType: 'mime-type',
+                        value: mimeType,
+                    });
+                }
+                : null,
+            onName: postName
+                ? async (name) => {
+                    await executeCallback({
+                        callbackType: 'name',
+                        value: name,
+                    });
+                }
+                : null,
+            onNumberOfAudioChannels: postNumberOfAudioChannels
+                ? async (numberOfChannels) => {
+                    await executeCallback({
+                        callbackType: 'number-of-audio-channels',
+                        value: numberOfChannels,
+                    });
+                }
+                : null,
+            onRotation: postRotation
+                ? async (rotation) => {
+                    await executeCallback({
+                        callbackType: 'rotation',
+                        value: rotation,
+                    });
+                }
+                : null,
+            onSampleRate: postSampleRate
+                ? async (sampleRate) => {
+                    await executeCallback({
+                        callbackType: 'sample-rate',
+                        value: sampleRate,
+                    });
+                }
+                : null,
+            onSize: postSize
+                ? async (size) => {
+                    await executeCallback({
+                        callbackType: 'size',
+                        value: size,
+                    });
+                }
+                : null,
+            onSlowAudioBitrate: postSlowAudioBitrate
+                ? async (audioBitrate) => {
+                    await executeCallback({
+                        callbackType: 'slow-audio-bitrate',
+                        value: audioBitrate,
+                    });
+                }
+                : null,
+            onSlowDurationInSeconds: postSlowDurationInSeconds
+                ? async (durationInSeconds) => {
+                    await executeCallback({
+                        callbackType: 'slow-duration-in-seconds',
+                        value: durationInSeconds,
+                    });
+                }
+                : null,
+            onSlowFps: postSlowFps
+                ? async (fps) => {
+                    await executeCallback({
+                        callbackType: 'slow-fps',
+                        value: fps,
+                    });
+                }
+                : null,
+            onSlowKeyframes: postSlowKeyframes
+                ? async (keyframes) => {
+                    await executeCallback({
+                        callbackType: 'slow-keyframes',
+                        value: keyframes,
+                    });
+                }
+                : null,
+            onSlowNumberOfFrames: postSlowNumberOfFrames
+                ? async (numberOfFrames) => {
+                    await executeCallback({
+                        callbackType: 'slow-number-of-frames',
+                        value: numberOfFrames,
+                    });
+                }
+                : null,
+            onSlowVideoBitrate: postSlowVideoBitrate
+                ? async (videoBitrate) => {
+                    await executeCallback({
+                        callbackType: 'slow-video-bitrate',
+                        value: videoBitrate,
+                    });
+                }
+                : null,
+            onStructure: postStructure
+                ? async (structure) => {
+                    await executeCallback({
+                        callbackType: 'structure',
+                        value: structure,
+                    });
+                }
+                : null,
+            onTracks: postTracks
+                ? async (tracks) => {
+                    await executeCallback({
+                        callbackType: 'tracks',
+                        value: tracks,
+                    });
+                }
+                : null,
+            onUnrotatedDimensions: postUnrotatedDimensions
+                ? async (dimensions) => {
+                    await executeCallback({
+                        callbackType: 'unrotated-dimensions',
+                        value: dimensions,
+                    });
+                }
+                : null,
+            onVideoCodec: postVideoCodec
+                ? async (codec) => {
+                    await executeCallback({
+                        callbackType: 'video-codec',
+                        value: codec,
+                    });
+                }
+                : null,
+            onDurationInSeconds: postDurationInSeconds
+                ? async (durationInSeconds) => {
+                    await executeCallback({
+                        callbackType: 'duration-in-seconds',
+                        value: durationInSeconds,
+                    });
+                }
+                : null,
+            onParseProgress: postParseProgress
+                ? async (progress) => {
+                    await executeCallback({
+                        callbackType: 'parse-progress',
+                        value: progress,
+                    });
+                }
+                : null,
+            progressIntervalInMs: progressIntervalInMs !== null && progressIntervalInMs !== void 0 ? progressIntervalInMs : null,
+            selectM3uStream: postM3uStreamSelection
+                ? async (streamIndex) => {
+                    const res = await executeCallback({
+                        callbackType: 'm3u-stream-selection',
+                        value: streamIndex,
+                    });
+                    if (res.payloadType !== 'm3u-stream-selection') {
+                        throw new Error('Invalid response from callback');
+                    }
+                    return res.value;
+                }
+                : defaultSelectM3uStreamFn,
+            mp4HeaderSegment: mp4HeaderSegment !== null && mp4HeaderSegment !== void 0 ? mp4HeaderSegment : null,
+            selectM3uAssociatedPlaylists: postM3uAssociatedPlaylistsSelection
+                ? async (playlists) => {
+                    const res = await executeCallback({
+                        callbackType: 'm3u-associated-playlists-selection',
+                        value: playlists,
+                    });
+                    if (res.payloadType !== 'm3u-associated-playlists-selection') {
+                        throw new Error('Invalid response from callback');
+                    }
+                    return res.value;
+                }
+                : defaultSelectM3uAssociatedPlaylists,
+            onAudioTrack: postOnAudioTrack
+                ? async (params) => {
+                    const res = await executeCallback({
+                        callbackType: 'on-audio-track',
+                        value: params,
+                    });
+                    if (res.payloadType !== 'on-audio-track-response') {
+                        throw new Error('Invalid response from callback');
+                    }
+                    if (!res.registeredCallback) {
+                        return null;
+                    }
+                    return async (sample) => {
+                        await executeCallback({
+                            callbackType: 'on-audio-video-sample',
+                            value: sample,
+                            trackId: params.track.trackId,
+                        });
+                    };
+                }
+                : null,
+            onVideoTrack: postOnVideoTrack
+                ? async (params) => {
+                    const res = await executeCallback({
+                        callbackType: 'on-video-track',
+                        value: params,
+                    });
+                    if (res.payloadType !== 'on-video-track-response') {
+                        throw new Error('Invalid response from callback');
+                    }
+                    if (!res.registeredCallback) {
+                        return null;
+                    }
+                    return async (sample) => {
+                        await executeCallback({
+                            callbackType: 'on-audio-video-sample',
+                            value: sample,
+                            trackId: params.track.trackId,
+                        });
+                    };
+                }
+                : null,
+            onDiscardedData: null,
+        });
+        post({
+            type: 'response-done',
+            payload: ret,
+        });
+    }
+    catch (e) {
+        post(serializeError(e, logLevel));
+    }
+};
+const onMessageForWorker = forwardMediaParserControllerToWorker(controller);
+export const messageHandler = (message, readerInterface) => {
+    const data = message.data;
+    if (data.type === 'request-worker') {
+        startParsing(data, readerInterface);
+        return;
+    }
+    // not handled here
+    if (data.type === 'acknowledge-callback') {
+        return;
+    }
+    if (data.type === 'signal-error-in-callback') {
+        return;
+    }
+    onMessageForWorker(data);
+};

package/dist/worker-web-entry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker-web-entry.js

@@ -0,0 +1,5 @@
+import { webReader } from './readers/web';
+import { messageHandler } from './worker-server';
+addEventListener('message', (message) => {
+    messageHandler(message, webReader);
+});

package/dist/worker.d.ts

@@ -0,0 +1,2 @@
+import type { ParseMedia } from './options';
+export declare const parseMediaOnWorker: ParseMedia;

package/dist/worker.js

@@ -0,0 +1,267 @@
+import { deserializeError } from './worker/serialize-error';
+const convertToWorkerPayload = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+payload) => {
+    const { onAudioCodec, onContainer, onDimensions, onUnrotatedDimensions, onVideoCodec, onFps, onAudioTrack, onDurationInSeconds, onImages, onInternalStats, onIsHdr, onKeyframes, onLocation, onM3uStreams, onMetadata, onMimeType, onName, onNumberOfAudioChannels, 
+    // TODO: Callback functions
+    onParseProgress, onRotation, onSampleRate, onSlowAudioBitrate, onSize, onSlowDurationInSeconds, onSlowFps, onSlowKeyframes, onSlowNumberOfFrames, onSlowVideoBitrate, onStructure, onTracks, onVideoTrack, selectM3uStream, selectM3uAssociatedPlaylists, ...others } = payload;
+    return {
+        type: 'request-worker',
+        payload: others,
+        postAudioCodec: Boolean(onAudioCodec),
+        postContainer: Boolean(onContainer),
+        postDimensions: Boolean(onDimensions),
+        postDurationInSeconds: Boolean(onDurationInSeconds),
+        postFps: Boolean(onFps),
+        postImages: Boolean(onImages),
+        postInternalStats: Boolean(onInternalStats),
+        postIsHdr: Boolean(onIsHdr),
+        postKeyframes: Boolean(onKeyframes),
+        postLocation: Boolean(onLocation),
+        postM3uStreams: Boolean(onM3uStreams),
+        postMetadata: Boolean(onMetadata),
+        postMimeType: Boolean(onMimeType),
+        postName: Boolean(onName),
+        postNumberOfAudioChannels: Boolean(onNumberOfAudioChannels),
+        postRotation: Boolean(onRotation),
+        postSampleRate: Boolean(onSampleRate),
+        postSlowAudioBitrate: Boolean(onSlowAudioBitrate),
+        postSlowDurationInSeconds: Boolean(onSlowDurationInSeconds),
+        postSlowFps: Boolean(onSlowFps),
+        postSlowKeyframes: Boolean(onSlowKeyframes),
+        postSlowNumberOfFrames: Boolean(onSlowNumberOfFrames),
+        postSlowVideoBitrate: Boolean(onSlowVideoBitrate),
+        postStructure: Boolean(onStructure),
+        postTracks: Boolean(onTracks),
+        postUnrotatedDimensions: Boolean(onUnrotatedDimensions),
+        postVideoCodec: Boolean(onVideoCodec),
+        postSize: Boolean(onSize),
+        postParseProgress: Boolean(onParseProgress),
+        postM3uStreamSelection: Boolean(selectM3uStream),
+        postM3uAssociatedPlaylistsSelection: Boolean(selectM3uAssociatedPlaylists),
+        postOnAudioTrack: Boolean(onAudioTrack),
+        postOnVideoTrack: Boolean(onVideoTrack),
+    };
+};
+const post = (worker, payload) => {
+    worker.postMessage(payload);
+};
+export const parseMediaOnWorker = async ({ controller, ...params }) => {
+    if (typeof Worker === 'undefined') {
+        throw new Error('"Worker" is not available. Cannot call workerClient()');
+    }
+    const worker = new Worker(new URL('./worker-server', import.meta.url));
+    post(worker, convertToWorkerPayload(params));
+    const { promise, resolve, reject } = Promise.withResolvers();
+    const onAbort = () => {
+        post(worker, { type: 'request-abort' });
+    };
+    const onResume = () => {
+        post(worker, { type: 'request-resume' });
+    };
+    const onPause = () => {
+        post(worker, { type: 'request-pause' });
+    };
+    const callbacks = {};
+    function onMessage(message) {
+        const data = message.data;
+        if (data.type === 'response-done') {
+            resolve(data.payload);
+        }
+        if (data.type === 'response-error') {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            cleanup();
+            reject(deserializeError(data));
+        }
+        if (data.type === 'response-on-callback-request') {
+            Promise.resolve()
+                .then(async () => {
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6;
+                if (data.payload.callbackType === 'audio-codec') {
+                    await ((_a = params.onAudioCodec) === null || _a === void 0 ? void 0 : _a.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'container') {
+                    await ((_b = params.onContainer) === null || _b === void 0 ? void 0 : _b.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'dimensions') {
+                    await ((_c = params.onDimensions) === null || _c === void 0 ? void 0 : _c.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'unrotated-dimensions') {
+                    await ((_d = params.onUnrotatedDimensions) === null || _d === void 0 ? void 0 : _d.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'video-codec') {
+                    await ((_e = params.onVideoCodec) === null || _e === void 0 ? void 0 : _e.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'tracks') {
+                    await ((_f = params.onTracks) === null || _f === void 0 ? void 0 : _f.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'rotation') {
+                    await ((_g = params.onRotation) === null || _g === void 0 ? void 0 : _g.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'sample-rate') {
+                    await ((_h = params.onSampleRate) === null || _h === void 0 ? void 0 : _h.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-audio-bitrate') {
+                    await ((_j = params.onSlowAudioBitrate) === null || _j === void 0 ? void 0 : _j.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-duration-in-seconds') {
+                    await ((_k = params.onSlowDurationInSeconds) === null || _k === void 0 ? void 0 : _k.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-fps') {
+                    await ((_l = params.onSlowFps) === null || _l === void 0 ? void 0 : _l.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-keyframes') {
+                    await ((_m = params.onSlowKeyframes) === null || _m === void 0 ? void 0 : _m.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-number-of-frames') {
+                    await ((_o = params.onSlowNumberOfFrames) === null || _o === void 0 ? void 0 : _o.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'slow-video-bitrate') {
+                    await ((_p = params.onSlowVideoBitrate) === null || _p === void 0 ? void 0 : _p.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'structure') {
+                    await ((_q = params.onStructure) === null || _q === void 0 ? void 0 : _q.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'fps') {
+                    await ((_r = params.onFps) === null || _r === void 0 ? void 0 : _r.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'images') {
+                    await ((_s = params.onImages) === null || _s === void 0 ? void 0 : _s.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'internal-stats') {
+                    await ((_t = params.onInternalStats) === null || _t === void 0 ? void 0 : _t.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'is-hdr') {
+                    await ((_u = params.onIsHdr) === null || _u === void 0 ? void 0 : _u.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'keyframes') {
+                    await ((_v = params.onKeyframes) === null || _v === void 0 ? void 0 : _v.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'location') {
+                    await ((_w = params.onLocation) === null || _w === void 0 ? void 0 : _w.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'm3u-streams') {
+                    await ((_x = params.onM3uStreams) === null || _x === void 0 ? void 0 : _x.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'metadata') {
+                    await ((_y = params.onMetadata) === null || _y === void 0 ? void 0 : _y.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'mime-type') {
+                    await ((_z = params.onMimeType) === null || _z === void 0 ? void 0 : _z.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'name') {
+                    await ((_0 = params.onName) === null || _0 === void 0 ? void 0 : _0.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'number-of-audio-channels') {
+                    await ((_1 = params.onNumberOfAudioChannels) === null || _1 === void 0 ? void 0 : _1.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'size') {
+                    await ((_2 = params.onSize) === null || _2 === void 0 ? void 0 : _2.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'duration-in-seconds') {
+                    await ((_3 = params.onDurationInSeconds) === null || _3 === void 0 ? void 0 : _3.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'parse-progress') {
+                    await ((_4 = params.onParseProgress) === null || _4 === void 0 ? void 0 : _4.call(params, data.payload.value));
+                    return { payloadType: 'void' };
+                }
+                if (data.payload.callbackType === 'm3u-stream-selection') {
+                    const selection = await params.selectM3uStream(data.payload.value);
+                    return { payloadType: 'm3u-stream-selection', value: selection };
+                }
+                if (data.payload.callbackType === 'm3u-associated-playlists-selection') {
+                    const selection = await params.selectM3uAssociatedPlaylists(data.payload.value);
+                    return {
+                        payloadType: 'm3u-associated-playlists-selection',
+                        value: selection,
+                    };
+                }
+                if (data.payload.callbackType === 'on-audio-track') {
+                    const possibleCallback = await ((_5 = params.onAudioTrack) === null || _5 === void 0 ? void 0 : _5.call(params, data.payload.value));
+                    if (possibleCallback) {
+                        callbacks[data.payload.value.track.trackId] = possibleCallback;
+                    }
+                    return {
+                        payloadType: 'on-audio-track-response',
+                        registeredCallback: Boolean(possibleCallback),
+                    };
+                }
+                if (data.payload.callbackType === 'on-video-track') {
+                    const possibleCallback = await ((_6 = params.onVideoTrack) === null || _6 === void 0 ? void 0 : _6.call(params, data.payload.value));
+                    if (possibleCallback) {
+                        callbacks[data.payload.value.track.trackId] = possibleCallback;
+                    }
+                    return {
+                        payloadType: 'on-video-track-response',
+                        registeredCallback: Boolean(possibleCallback),
+                    };
+                }
+                if (data.payload.callbackType === 'on-audio-video-sample') {
+                    const callback = callbacks[data.payload.trackId];
+                    if (!callback) {
+                        throw new Error(`No callback registered for track ${data.payload.trackId}`);
+                    }
+                    await callback(data.payload.value);
+                    return { payloadType: 'void' };
+                }
+                throw new Error(`Unknown callback type: ${data.payload}`);
+            })
+                .then((payload) => {
+                post(worker, {
+                    type: 'acknowledge-callback',
+                    nonce: data.nonce,
+                    ...payload,
+                });
+            })
+                .catch((err) => {
+                reject(err);
+                post(worker, {
+                    type: 'signal-error-in-callback',
+                    nonce: data.nonce,
+                });
+            });
+        }
+    }
+    worker.addEventListener('message', onMessage);
+    controller === null || controller === void 0 ? void 0 : controller.addEventListener('abort', onAbort);
+    controller === null || controller === void 0 ? void 0 : controller.addEventListener('resume', onResume);
+    controller === null || controller === void 0 ? void 0 : controller.addEventListener('pause', onPause);
+    function cleanup() {
+        worker.removeEventListener('message', onMessage);
+        controller === null || controller === void 0 ? void 0 : controller.removeEventListener('abort', onAbort);
+        controller === null || controller === void 0 ? void 0 : controller.removeEventListener('resume', onResume);
+        controller === null || controller === void 0 ? void 0 : controller.removeEventListener('pause', onPause);
+        worker.terminate();
+    }
+    const val = await promise;
+    cleanup();
+    return val;
+};