@zip.js/zip.js 2.8.53 → 2.8.54

package/lib/core/configuration.js

@@ -32,8 +32,15 @@ import {
 	UNDEFINED_VALUE,
 	UNDEFINED_TYPE
 } from "./constants.js";
+import {
+	checkFunctionOption,
+	toNumber
+} from "./options.js";
 
+const DEFAULT_CHUNK_SIZE = 64 * 1024;
 const MINIMUM_CHUNK_SIZE = 64;
+const MINIMUM_PROPERTY_VALUE = 1;
+const ERR_INVALID_MAX_WORKERS = "Invalid maxWorkers (must be an integer greater than 0)";
 let maxWorkers = 2;
 try {
 	if (typeof navigator != UNDEFINED_TYPE && navigator.hardwareConcurrency) {
@@ -45,7 +52,7 @@ try {
 const DEFAULT_CONFIGURATION = {
 	workerURI: "./core/web-worker-wasm.js",
 	wasmURI: "./core/streams/zlib-wasm/zlib-streams.wasm",
-	chunkSize: 64 * 1024,
+	chunkSize: DEFAULT_CHUNK_SIZE,
 	maxWorkers,
 	terminateWorkerTimeout: 5000,
 	workerStarvationTimeout: 5000,
@@ -57,24 +64,38 @@ const DEFAULT_CONFIGURATION = {
 	DecompressionStream: typeof DecompressionStream != UNDEFINED_TYPE && DecompressionStream
 };
 
-const CONFIGURABLE_PROPERTY_NAMES = [
+const PROPERTY_NAME_MAX_WORKERS = "maxWorkers";
+
+const STRING_PROPERTY_NAMES = [
 	"baseURI",
 	"wasmURI",
-	"workerURI",
-	"createWorker",
+	"workerURI"
+];
+const BOOLEAN_PROPERTY_NAMES = [
+	"useCompressionStream",
+	"useWebWorkers",
+	"transferStreams"
+];
+const NUMBER_PROPERTY_NAMES = [
 	"chunkSize",
-	"maxWorkers",
+	PROPERTY_NAME_MAX_WORKERS,
 	"terminateWorkerTimeout",
 	"workerStarvationTimeout",
-	"workerStartupTimeout",
-	"useCompressionStream",
-	"useWebWorkers",
-	"transferStreams",
+	"workerStartupTimeout"
+];
+const FUNCTION_PROPERTY_NAMES = [
+	"createWorker",
 	"CompressionStream",
 	"DecompressionStream",
 	"CompressionStreamFallback",
 	"DecompressionStreamFallback"
 ];
+const CONFIGURABLE_PROPERTY_NAMES = [
+	...STRING_PROPERTY_NAMES,
+	...BOOLEAN_PROPERTY_NAMES,
+	...NUMBER_PROPERTY_NAMES,
+	...FUNCTION_PROPERTY_NAMES
+];
 
 const config = { ...DEFAULT_CONFIGURATION };
 
@@ -83,7 +104,9 @@ export {
 	setDefaultConfiguration,
 	resetConfiguration,
 	getConfiguration,
-	getChunkSize
+	getChunkSize,
+	normalizeChunkSize,
+	ERR_INVALID_MAX_WORKERS
 };
 
 function getConfiguration() {
@@ -91,20 +114,43 @@ function getConfiguration() {
 }
 
 function getChunkSize(config) {
-	return Math.max(config.chunkSize, MINIMUM_CHUNK_SIZE);
+	return normalizeChunkSize(config.chunkSize);
+}
+
+function normalizeChunkSize(chunkSize) {
+	chunkSize = toNumber(chunkSize);
+	return Number.isInteger(chunkSize) && chunkSize >= MINIMUM_PROPERTY_VALUE ? Math.max(chunkSize, MINIMUM_CHUNK_SIZE) : DEFAULT_CHUNK_SIZE;
 }
 
 function configure(configuration) {
-	configuration = normalizeConfiguration(configuration);
+	Object.assign(config, checkConfiguration(normalizeConfiguration(configuration)));
+}
+
+function checkConfiguration(configuration) {
+	const checkedConfiguration = {};
 	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
 		const propertyValue = configuration[propertyName];
 		if (propertyValue !== UNDEFINED_VALUE) {
-			config[propertyName] = propertyValue;
+			checkedConfiguration[propertyName] = checkPropertyValue(propertyName, propertyValue);
 		}
 	}
+	return checkedConfiguration;
+}
+
+function checkPropertyValue(propertyName, propertyValue) {
+	if (NUMBER_PROPERTY_NAMES.includes(propertyName)) {
+		propertyValue = toNumber(propertyValue);
+		if (propertyName == PROPERTY_NAME_MAX_WORKERS && (!Number.isInteger(propertyValue) || propertyValue < MINIMUM_PROPERTY_VALUE)) {
+			throw new Error(ERR_INVALID_MAX_WORKERS);
+		}
+	} else if (FUNCTION_PROPERTY_NAMES.includes(propertyName)) {
+		checkFunctionOption(propertyValue);
+	}
+	return propertyValue;
 }
 
 function normalizeConfiguration(configuration) {
+	configuration = configuration || {};
 	const { CompressionStreamZlib, DecompressionStreamZlib } = configuration;
 	if (CompressionStreamZlib === UNDEFINED_VALUE && DecompressionStreamZlib === UNDEFINED_VALUE) {
 		return configuration;
@@ -120,14 +166,9 @@ function normalizeConfiguration(configuration) {
 }
 
 function setDefaultConfiguration(configuration) {
-	configuration = normalizeConfiguration(configuration);
-	for (const propertyName of CONFIGURABLE_PROPERTY_NAMES) {
-		const propertyValue = configuration[propertyName];
-		if (propertyValue !== UNDEFINED_VALUE) {
-			DEFAULT_CONFIGURATION[propertyName] = propertyValue;
-		}
-	}
-	configure(configuration);
+	const checkedConfiguration = checkConfiguration(normalizeConfiguration(configuration));
+	Object.assign(DEFAULT_CONFIGURATION, checkedConfiguration);
+	Object.assign(config, checkedConfiguration);
 }
 
 function resetConfiguration() {

package/lib/core/constants.js

@@ -36,6 +36,7 @@ const COMPRESSION_METHOD_AES = 0x63;
 
 const LOCAL_FILE_HEADER_SIGNATURE = 0x04034b50;
 const SPLIT_ZIP_FILE_SIGNATURE = 0x08074b50;
+const TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE = 0x30304b50;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE = SPLIT_ZIP_FILE_SIGNATURE;
 const ARCHIVE_EXTRA_DATA_SIGNATURE = 0x08064b50;
 const DIGITAL_SIGNATURE_RECORD_SIGNATURE = 0x05054b50;
@@ -52,6 +53,7 @@ const ZIP64_END_OF_CENTRAL_DIR_TOTAL_LENGTH = END_OF_CENTRAL_DIR_LENGTH + ZIP64_
 const DATA_DESCRIPTOR_RECORD_LENGTH = 12;
 const DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH = 20;
 const DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH = 4;
+const SPLIT_ZIP_FILE_SIGNATURE_LENGTH = 4;
 
 const EXTRAFIELD_TYPE_ZIP64 = 0x0001;
 const EXTRAFIELD_TYPE_AES = 0x9901;
@@ -103,6 +105,8 @@ const HEADER_OFFSET_VERSION = 0;
 const HEADER_OFFSET_SIGNATURE = 10;
 const HEADER_OFFSET_COMPRESSED_SIZE = 14;
 const HEADER_OFFSET_UNCOMPRESSED_SIZE = 18;
+const HEADER_OFFSET_FILENAME_LENGTH = 22;
+const HEADER_OFFSET_EXTRAFIELD_LENGTH = 24;
 const LOCAL_HEADER_COMMON_OFFSET = 4;
 
 const MAX_DATE = new Date(2107, 11, 31, 23, 59, 58);
@@ -115,6 +119,7 @@ const FUNCTION_TYPE = "function";
 const OBJECT_TYPE = "object";
 const STRING_TYPE = "string";
 const NUMBER_TYPE = "number";
+const BOOLEAN_TYPE = "boolean";
 
 const EMPTY_UINT8_ARRAY = new Uint8Array();
 
@@ -128,6 +133,7 @@ export {
 	COMPRESSION_METHOD_STORE,
 	COMPRESSION_METHOD_AES,
 	SPLIT_ZIP_FILE_SIGNATURE,
+	TEMPORARY_SPLIT_ZIP_FILE_SIGNATURE,
 	ARCHIVE_EXTRA_DATA_SIGNATURE,
 	DIGITAL_SIGNATURE_RECORD_SIGNATURE,
 	LOCAL_FILE_HEADER_SIGNATURE,
@@ -140,6 +146,7 @@ export {
 	DATA_DESCRIPTOR_RECORD_LENGTH,
 	DATA_DESCRIPTOR_RECORD_ZIP_64_LENGTH,
 	DATA_DESCRIPTOR_RECORD_SIGNATURE_LENGTH,
+	SPLIT_ZIP_FILE_SIGNATURE_LENGTH,
 	EXTRAFIELD_TYPE_ZIP64,
 	EXTRAFIELD_TYPE_AES,
 	EXTRAFIELD_TYPE_NTFS,
@@ -188,6 +195,8 @@ export {
 	HEADER_OFFSET_SIGNATURE,
 	HEADER_OFFSET_COMPRESSED_SIZE,
 	HEADER_OFFSET_UNCOMPRESSED_SIZE,
+	HEADER_OFFSET_FILENAME_LENGTH,
+	HEADER_OFFSET_EXTRAFIELD_LENGTH,
 	LOCAL_HEADER_COMMON_OFFSET,
 	DIRECTORY_SIGNATURE,
 	MIN_DATE,
@@ -198,5 +207,6 @@ export {
 	FUNCTION_TYPE,
 	OBJECT_TYPE,
 	STRING_TYPE,
-	NUMBER_TYPE
+	NUMBER_TYPE,
+	BOOLEAN_TYPE
 };

package/lib/core/io.js

@@ -26,7 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream, FileReader, TransformStream */
+/* global Blob, atob, btoa, XMLHttpRequest, URL, fetch, ReadableStream, WritableStream, TransformStream */
 // deno-lint-ignore-file no-this-alias
 
 import {
@@ -36,9 +36,10 @@ import {
 	END_OF_CENTRAL_DIR_LENGTH,
 	EMPTY_UINT8_ARRAY
 } from "./constants.js";
-import { getConfiguration, getChunkSize } from "./configuration.js";
+import { getConfiguration, getChunkSize, normalizeChunkSize } from "./configuration.js";
 import { concat, toExactUint8Array } from "./util/array.js";
 import { toCompatibleReadable, toCompatibleWritable, streamToBlob } from "./util/compatible-streams.js";
+import { decodeTextRemovingBOM } from "./util/decode-text.js";
 
 const ERR_HTTP_STATUS = "HTTP error ";
 const ERR_HTTP_RANGE = "HTTP Range not supported";
@@ -83,6 +84,7 @@ class Reader extends Stream {
 	createReadable({ offset = 0, size, chunkSize = getChunkSize(getConfiguration()) } = {}) {
 		const reader = this;
 		let chunkOffset = 0;
+		chunkSize = normalizeChunkSize(chunkSize);
 		return new ReadableStream({
 			async pull(controller) {
 				const dataSize = size === UNDEFINED_VALUE ? chunkSize : Math.min(chunkSize, size - chunkOffset);
@@ -90,7 +92,7 @@ class Reader extends Stream {
 				if (data.length) {
 					controller.enqueue(data);
 				}
-				if ((chunkOffset + chunkSize >= size) || (size === UNDEFINED_VALUE && !data.length && dataSize)) {
+				if ((chunkOffset + chunkSize >= size) || (!data.length && dataSize)) {
 					controller.close();
 				} else {
 					chunkOffset += chunkSize;
@@ -170,31 +172,31 @@ class Data64URIWriter extends Writer {
 		Object.assign(this, {
 			contentType,
 			data: "data:" + (contentType || "") + ";base64,",
-			pending: []
+			pendingCharacters: ""
 		});
 	}
 
 	writeUint8Array(array) {
 		const writer = this;
 		let indexArray;
-		let dataString = writer.pending;
-		const delta = writer.pending.length;
-		writer.pending = "";
+		let dataString = writer.pendingCharacters;
+		const delta = writer.pendingCharacters.length;
+		writer.pendingCharacters = "";
 		for (indexArray = 0; indexArray < (Math.floor((delta + array.length) / 3) * 3) - delta; indexArray++) {
 			dataString += String.fromCharCode(array[indexArray]);
 		}
 		for (; indexArray < array.length; indexArray++) {
-			writer.pending += String.fromCharCode(array[indexArray]);
+			writer.pendingCharacters += String.fromCharCode(array[indexArray]);
 		}
 		if (dataString.length > 2) {
 			writer.data += btoa(dataString);
 		} else {
-			writer.pending = dataString + writer.pending;
+			writer.pendingCharacters = dataString + writer.pendingCharacters;
 		}
 	}
 
 	getData() {
-		return this.data + btoa(this.pending);
+		return this.data + btoa(this.pendingCharacters);
 	}
 }
 
@@ -224,7 +226,7 @@ class BlobReader extends Reader {
 	constructor(blob) {
 		super();
 		Object.assign(this, {
-			blob,
+			sourceBlob: blob,
 			size: blob.size
 		});
 		if (!blobSliceProbe) {
@@ -234,13 +236,13 @@ class BlobReader extends Reader {
 
 	createReadable(options) {
 		const reader = this;
-		const { blob, size } = reader;
+		const { sourceBlob, size } = reader;
 		const { offset = 0, size: readSize = size - offset } = options || {};
 		if (!offset && readSize >= size) {
-			return toCompatibleReadable(blob.stream());
+			return toCompatibleReadable(sourceBlob.stream());
 		}
 		if (blobSliceReliable) {
-			return toCompatibleReadable(blob.slice(offset, offset + readSize).stream());
+			return toCompatibleReadable(sourceBlob.slice(offset, offset + readSize).stream());
 		}
 		return super.createReadable(options);
 	}
@@ -249,7 +251,7 @@ class BlobReader extends Reader {
 		const reader = this;
 		const offsetEnd = offset + length;
 		const readsWholeBlob = !offset && offsetEnd >= reader.size;
-		const blob = readsWholeBlob ? reader.blob : reader.blob.slice(offset, offsetEnd);
+		const blob = readsWholeBlob ? reader.sourceBlob : reader.sourceBlob.slice(offset, offsetEnd);
 		let arrayBuffer = await blob.arrayBuffer();
 		const sliceIgnoredByBuggyImplementation = arrayBuffer.byteLength > length;
 		if (sliceIgnoredByBuggyImplementation) {
@@ -271,12 +273,12 @@ class BlobWriter extends Stream {
 			}
 		});
 		writer.contentType = contentType;
-		writer.blob = streamToBlob(transformStream.readable, contentType);
-		writer.blob.catch(() => { });
+		writer.blobPromise = streamToBlob(transformStream.readable, contentType);
+		writer.blobPromise.catch(() => { });
 	}
 
 	getData() {
-		return this.blob;
+		return this.blobPromise;
 	}
 }
 
@@ -310,7 +312,7 @@ function getTextSize(text) {
 class TextWriter extends BlobWriter {
 
 	constructor(encoding) {
-		super(encoding);
+		super();
 		Object.assign(this, {
 			encoding,
 			utf8: !encoding || encoding.toLowerCase() == "utf-8"
@@ -326,14 +328,7 @@ class TextWriter extends BlobWriter {
 		if (blob.text && utf8) {
 			return blob.text();
 		} else {
-			const reader = new FileReader();
-			return new Promise((resolve, reject) => {
-				Object.assign(reader, {
-					onload: ({ target }) => resolve(target.result),
-					onerror: () => reject(reader.error)
-				});
-				reader.readAsText(blob, encoding);
-			});
+			return decodeTextRemovingBOM(new Uint8Array(await blob.arrayBuffer()), encoding);
 		}
 	}
 }
@@ -1001,8 +996,19 @@ function readUint8Array(reader, offset, size) {
 	return reader.readUint8Array(offset, size);
 }
 
+function createReadable(reader, options) {
+	if (reader.createReadable) {
+		return reader.createReadable(options);
+	} else if (reader.readUint8Array) {
+		return Reader.prototype.createReadable.call(reader, options);
+	} else {
+		return reader.readable;
+	}
+}
+
 export {
 	initStream,
+	createReadable,
 	GenericReader,
 	GenericWriter,
 	ownsWritable,

package/lib/core/options.js

@@ -26,6 +26,13 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+import {
+	BOOLEAN_TYPE,
+	FUNCTION_TYPE,
+	STRING_TYPE,
+	UNDEFINED_VALUE
+} from "./constants.js";
+
 const OPTION_FILENAME_ENCODING = "filenameEncoding";
 const OPTION_COMMENT_ENCODING = "commentEncoding";
 const OPTION_DECODE_TEXT = "decodeText";
@@ -75,6 +82,10 @@ const STRICTNESS_STRICT = "strict";
 const STRICTNESS_BALANCED = "balanced";
 const STRICTNESS_TOLERANT = "tolerant";
 
+const ERR_INVALID_FUNCTION_OPTION = "Invalid option (must be a function)";
+const ERR_INVALID_SIGNAL = "Invalid signal (must be an AbortSignal instance)";
+const ERR_INVALID_PASSWORD_TYPE = "Invalid password (password must be a string, rawPassword must be a Uint8Array)";
+
 export {
 	OPTION_FILENAME_ENCODING,
 	OPTION_COMMENT_ENCODING,
@@ -123,5 +134,36 @@ export {
 	TEXT_TYPE_COMMENT,
 	STRICTNESS_STRICT,
 	STRICTNESS_BALANCED,
-	STRICTNESS_TOLERANT
-};
+	STRICTNESS_TOLERANT,
+	ERR_INVALID_FUNCTION_OPTION,
+	ERR_INVALID_SIGNAL,
+	ERR_INVALID_PASSWORD_TYPE,
+	checkFunctionOption,
+	checkSignalOption,
+	checkPasswordOption,
+	toNumber
+};
+
+function checkFunctionOption(value) {
+	if (value && typeof value != FUNCTION_TYPE) {
+		throw new Error(ERR_INVALID_FUNCTION_OPTION);
+	}
+	return value;
+}
+
+function checkSignalOption(signal) {
+	if (signal && (typeof signal.addEventListener != FUNCTION_TYPE || typeof signal.aborted != BOOLEAN_TYPE)) {
+		throw new Error(ERR_INVALID_SIGNAL);
+	}
+	return signal || UNDEFINED_VALUE;
+}
+
+function checkPasswordOption(password, rawPassword) {
+	if ((password && typeof password != STRING_TYPE) || (rawPassword && !(rawPassword instanceof Uint8Array))) {
+		throw new Error(ERR_INVALID_PASSWORD_TYPE);
+	}
+}
+
+function toNumber(value) {
+	return typeof value == STRING_TYPE && value.trim() ? Number(value) : value;
+}

package/lib/core/streams/aes-crypto-stream.js

@@ -102,13 +102,13 @@ class AESDecryptionStream extends TransformStream {
 				const {
 					ctr,
 					hmac,
-					pending,
+					pendingInput,
 					ready
 				} = this;
 				if (hmac && ctr) {
 					await ready;
-					const chunkToDecrypt = subarray(pending, 0, pending.length - AUTHENTICATION_CODE_LENGTH);
-					const originalAuthenticationCode = subarray(pending, pending.length - AUTHENTICATION_CODE_LENGTH);
+					const chunkToDecrypt = subarray(pendingInput, 0, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
+					const originalAuthenticationCode = subarray(pendingInput, pendingInput.length - AUTHENTICATION_CODE_LENGTH);
 					let decryptedChunkArray = EMPTY_UINT8_ARRAY;
 					if (chunkToDecrypt.length) {
 						const encryptedChunk = toBits(codecBytes, chunkToDecrypt);
@@ -117,7 +117,7 @@ class AESDecryptionStream extends TransformStream {
 						decryptedChunkArray = fromBits(codecBytes, decryptedChunk);
 					}
 					const authenticationCode = subarray(fromBits(codecBytes, hmac.digest()), 0, AUTHENTICATION_CODE_LENGTH);
-					let invalidAuthenticationCode = pending.length < AUTHENTICATION_CODE_LENGTH ? 1 : 0;
+					let invalidAuthenticationCode = pendingInput.length < AUTHENTICATION_CODE_LENGTH ? 1 : 0;
 					for (let indexByte = 0; indexByte < AUTHENTICATION_CODE_LENGTH; indexByte++) {
 						invalidAuthenticationCode |= authenticationCode[indexByte] ^ originalAuthenticationCode[indexByte];
 					}
@@ -161,14 +161,14 @@ class AESEncryptionStream extends TransformStream {
 				const {
 					ctr,
 					hmac,
-					pending,
+					pendingInput,
 					ready
 				} = this;
 				if (hmac && ctr) {
 					await ready;
 					let encryptedChunkArray = EMPTY_UINT8_ARRAY;
-					if (pending.length) {
-						const encryptedChunk = ctr.update(toBits(codecBytes, pending));
+					if (pendingInput.length) {
+						const encryptedChunk = ctr.update(toBits(codecBytes, pendingInput));
 						hmac.update(encryptedChunk);
 						encryptedChunkArray = fromBits(codecBytes, encryptedChunk);
 					}
@@ -190,7 +190,7 @@ function initAesCrypto(aesCrypto, password, rawPassword, encryptionStrength) {
 		ready: new Promise(resolve => aesCrypto.resolveReady = resolve),
 		password: encodePassword(password, rawPassword),
 		strength: encryptionStrength - 1,
-		pending: EMPTY_UINT8_ARRAY
+		pendingInput: EMPTY_UINT8_ARRAY
 	});
 }
 
@@ -198,10 +198,10 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifyAuthen
 	const {
 		ctr,
 		hmac,
-		pending
+		pendingInput
 	} = aesCrypto;
-	if (pending.length) {
-		input = concat(pending, input);
+	if (pendingInput.length) {
+		input = concat(pendingInput, input);
 	}
 	const inputLength = input.length - paddingEnd;
 	output = expand(output, paddingStart + (inputLength - (inputLength % BLOCK_LENGTH)));
@@ -217,7 +217,7 @@ function append(aesCrypto, input, output, paddingStart, paddingEnd, verifyAuthen
 		}
 		output.set(fromBits(codecBytes, outputChunk), offset + paddingStart);
 	}
-	aesCrypto.pending = subarray(input, offset);
+	aesCrypto.pendingInput = subarray(input, offset);
 	return output;
 }
 

package/lib/core/util/decode-text.js

@@ -31,13 +31,22 @@
 import { decodeCP437 } from "./decode-cp437.js";
 
 export {
-	decodeText
+	decodeText,
+	decodeTextRemovingBOM
 };
 
 function decodeText(value, encoding) {
+	return decode(value, encoding, true);
+}
+
+function decodeTextRemovingBOM(value, encoding) {
+	return decode(value, encoding, false);
+}
+
+function decode(value, encoding, ignoreBOM) {
 	if (encoding && encoding.trim().toLowerCase() == "cp437") {
 		return decodeCP437(value);
 	} else {
-		return new TextDecoder(encoding, { ignoreBOM: true }).decode(value);
+		return new TextDecoder(encoding, { ignoreBOM }).decode(value);
 	}
 }

package/lib/core/web-worker-base.js

@@ -44,6 +44,7 @@ import {
 	MESSAGE_READY
 } from "./streams/codec-stream.js";
 import { getChunkSize } from "./configuration.js";
+import { toCompatibleReadable, toCompatibleWritable } from "./util/compatible-streams.js";
 import { toExactUint8Array } from "./util/array.js";
 import { ensureCodecStreams } from "./codec-registry.js";
 
@@ -138,7 +139,7 @@ async function init(message) {
 			config.DecompressionStreamFallback = config.DecompressionStreamZlib;
 		}
 		const strategy = { highWaterMark: 1 };
-		const readable = message.readable || new ReadableStream({
+		const readable = message.readable ? toCompatibleReadable(message.readable) : new ReadableStream({
 			async pull(controller) {
 				const result = new Promise(resolve => pendingPullMessages.set(messageId, resolve));
 				sendMessage({ type: MESSAGE_PULL, messageId });
@@ -150,7 +151,7 @@ async function init(message) {
 				}
 			}
 		}, strategy);
-		writable = message.writable || new WritableStream({
+		writable = message.writable ? toCompatibleWritable(message.writable) : new WritableStream({
 			async write(value) {
 				let resolveAckData;
 				const ackData = new Promise(resolve => resolveAckData = resolve);