Function init

lib/core/web-worker-base.js:71–132

(message)

});

async function init(message) {
	let codecStream;
	try {
		const { options, config } = message;
		if (!options.useCompressionStream) {
			try {
				await self.initModule(message.config);
			} catch {
				options.useCompressionStream = true;
			}
		}
		config.CompressionStream = self.CompressionStream;
		config.DecompressionStream = self.DecompressionStream;
		const strategy = { highWaterMark: 1 };
		const readable = message.readable || new ReadableStream({
			async pull(controller) {
				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
				sendMessage({ type: MESSAGE_PULL, messageId });
				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
				const { value, done } = await result;
				controller.enqueue(value);
				if (done) {
					controller.close();
				}
			}
		}, strategy);
		const writable = message.writable || new WritableStream({
			async write(value) {
				let resolveAckData;
				const ackData = new Promise(resolve => resolveAckData = resolve);
				pendingDataMessages.set(messageId, resolveAckData);
				sendMessage({ type: MESSAGE_DATA, value, messageId });
				messageId = (messageId + 1) % Number.MAX_SAFE_INTEGER;
				await ackData;
			}
		}, strategy);
		const codecStream = new CodecStream(options, config);
		abortController = new AbortController();
		const { signal } = abortController;
		await readable
			.pipeThrough(codecStream)
			.pipeThrough(new ChunkStream(config.chunkSize))
			.pipeTo(writable, { signal, preventClose: true, preventAbort: true });
		await writable.getWriter().close();
		const {
			signature,
			inputSize,
			outputSize
		} = codecStream;
		sendMessage({
			type: MESSAGE_CLOSE,
			result: {
				signature,
				inputSize,
				outputSize
			}
		});
	} catch (error) {