wpd-codec 3.5.0 → 3.5.2

package/dist/container/container.cjs

@@ -39,14 +39,13 @@ function unwrapContainer(bytes) {
 }
 function documentAreaEnd(bytes, header) {
 	const { fileSize, documentAreaOffset } = header;
-	if (fileSize > documentAreaOffset && fileSize <= bytes.length) return fileSize;
+	if (fileSize > documentAreaOffset) return Math.min(fileSize, bytes.length);
 	return bytes.length;
 }
 function openWpdDocument(input, options = {}) {
 	const { bytes: wrapped, compound, oleObjectStreams } = unwrapContainer(toArrayBufferBacked(input));
 	const header = require_container_header.readFileHeader(wrapped, options);
-	const suppliedPassword = options.password === "" ? void 0 : options.password;
-	const bytes = header.encryption !== 0 && suppliedPassword !== void 0 ? require_container_encryption.decryptWpdDocument(wrapped, header, suppliedPassword) : wrapped;
+	const bytes = header.encryption !== 0 && options.password !== void 0 ? require_container_encryption.decryptWpdDocument(wrapped, header, options.password) : wrapped;
 	return {
 		header,
 		packets: require_container_prefix.readPrefixPackets(bytes, header),

package/dist/container/container.js

@@ -38,14 +38,13 @@ function unwrapContainer(bytes) {
 }
 function documentAreaEnd(bytes, header) {
 	const { fileSize, documentAreaOffset } = header;
-	if (fileSize > documentAreaOffset && fileSize <= bytes.length) return fileSize;
+	if (fileSize > documentAreaOffset) return Math.min(fileSize, bytes.length);
 	return bytes.length;
 }
 function openWpdDocument(input, options = {}) {
 	const { bytes: wrapped, compound, oleObjectStreams } = unwrapContainer(toArrayBufferBacked(input));
 	const header = readFileHeader(wrapped, options);
-	const suppliedPassword = options.password === "" ? void 0 : options.password;
-	const bytes = header.encryption !== 0 && suppliedPassword !== void 0 ? decryptWpdDocument(wrapped, header, suppliedPassword) : wrapped;
+	const bytes = header.encryption !== 0 && options.password !== void 0 ? decryptWpdDocument(wrapped, header, options.password) : wrapped;
 	return {
 		header,
 		packets: readPrefixPackets(bytes, header),

package/dist/container/encryption.cjs

@@ -20,6 +20,11 @@ function wpdPasswordChecksum16(normalised) {
 	}
 	return checksum;
 }
+function passwordByteAt(normalised, relative) {
+	const value = normalised[relative % normalised.length];
+	if (value === void 0) throw new require_errors.WpdFormatError("The password normalised to no bytes, which the cipher cannot key with.");
+	return value;
+}
 function applyWpdStandardEncryption(bytes, normalised, startOffset) {
 	if (normalised.length === 0) throw new require_errors.WpdFormatError("The WordPerfect cipher is keyed by the password's own bytes, so an empty password decrypts nothing.");
 	const maskBase = normalised.length + 1 & 255;
@@ -27,10 +32,8 @@ function applyWpdStandardEncryption(bytes, normalised, startOffset) {
 	output.set(bytes.subarray(0, startOffset));
 	for (let pos = startOffset; pos < bytes.length; pos++) {
 		const relative = pos - startOffset;
-		const passwordByte = normalised[relative % normalised.length];
-		if (passwordByte === void 0) throw new require_errors.WpdFormatError("The password normalised to no bytes, which the cipher cannot key with.");
 		const mask = maskBase + relative & 255;
-		output[pos] = require_bytes_view.byteAt(bytes, pos) ^ passwordByte ^ mask;
+		output[pos] = require_bytes_view.byteAt(bytes, pos) ^ passwordByteAt(normalised, relative) ^ mask;
 	}
 	return output;
 }
@@ -56,4 +59,5 @@ exports.applyWpdStandardEncryption = applyWpdStandardEncryption;
 exports.decryptWpdDocument = decryptWpdDocument;
 exports.encryptWpdDocumentForTests = encryptWpdDocumentForTests;
 exports.normaliseWpdPassword = normaliseWpdPassword;
+exports.passwordByteAt = passwordByteAt;
 exports.wpdPasswordChecksum16 = wpdPasswordChecksum16;

package/dist/container/encryption.d.cts

@@ -2,8 +2,9 @@ import { i as WpdFileHeader } from "../header-Ca8QZVe3.cjs";
 //#region src/container/encryption.d.ts
 declare function normaliseWpdPassword(password: string): number[];
 declare function wpdPasswordChecksum16(normalised: readonly number[]): number;
+declare function passwordByteAt(normalised: readonly number[], relative: number): number;
 declare function applyWpdStandardEncryption(bytes: Uint8Array, normalised: readonly number[], startOffset: number): Uint8Array<ArrayBuffer>;
 declare function decryptWpdDocument(bytes: Uint8Array<ArrayBuffer>, header: WpdFileHeader, password: string): Uint8Array<ArrayBuffer>;
 declare function encryptWpdDocumentForTests(bytes: Uint8Array, password: string): Uint8Array<ArrayBuffer>;
 //#endregion
-export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, wpdPasswordChecksum16 };
+export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, passwordByteAt, wpdPasswordChecksum16 };

package/dist/container/encryption.d.ts

@@ -2,8 +2,9 @@ import { i as WpdFileHeader } from "../header-Ca8QZVe3.js";
 //#region src/container/encryption.d.ts
 declare function normaliseWpdPassword(password: string): number[];
 declare function wpdPasswordChecksum16(normalised: readonly number[]): number;
+declare function passwordByteAt(normalised: readonly number[], relative: number): number;
 declare function applyWpdStandardEncryption(bytes: Uint8Array, normalised: readonly number[], startOffset: number): Uint8Array<ArrayBuffer>;
 declare function decryptWpdDocument(bytes: Uint8Array<ArrayBuffer>, header: WpdFileHeader, password: string): Uint8Array<ArrayBuffer>;
 declare function encryptWpdDocumentForTests(bytes: Uint8Array, password: string): Uint8Array<ArrayBuffer>;
 //#endregion
-export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, wpdPasswordChecksum16 };
+export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, passwordByteAt, wpdPasswordChecksum16 };

package/dist/container/encryption.js

@@ -19,6 +19,11 @@ function wpdPasswordChecksum16(normalised) {
 	}
 	return checksum;
 }
+function passwordByteAt(normalised, relative) {
+	const value = normalised[relative % normalised.length];
+	if (value === void 0) throw new WpdFormatError("The password normalised to no bytes, which the cipher cannot key with.");
+	return value;
+}
 function applyWpdStandardEncryption(bytes, normalised, startOffset) {
 	if (normalised.length === 0) throw new WpdFormatError("The WordPerfect cipher is keyed by the password's own bytes, so an empty password decrypts nothing.");
 	const maskBase = normalised.length + 1 & 255;
@@ -26,10 +31,8 @@ function applyWpdStandardEncryption(bytes, normalised, startOffset) {
 	output.set(bytes.subarray(0, startOffset));
 	for (let pos = startOffset; pos < bytes.length; pos++) {
 		const relative = pos - startOffset;
-		const passwordByte = normalised[relative % normalised.length];
-		if (passwordByte === void 0) throw new WpdFormatError("The password normalised to no bytes, which the cipher cannot key with.");
 		const mask = maskBase + relative & 255;
-		output[pos] = byteAt(bytes, pos) ^ passwordByte ^ mask;
+		output[pos] = byteAt(bytes, pos) ^ passwordByteAt(normalised, relative) ^ mask;
 	}
 	return output;
 }
@@ -51,4 +54,4 @@ function encryptWpdDocumentForTests(bytes, password) {
 	return output;
 }
 //#endregion
-export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, wpdPasswordChecksum16 };
+export { applyWpdStandardEncryption, decryptWpdDocument, encryptWpdDocumentForTests, normaliseWpdPassword, passwordByteAt, wpdPasswordChecksum16 };

package/dist/container/header.cjs

@@ -13,7 +13,6 @@ const PRODUCT_TYPE_WORDPERFECT = 1;
 const DOCUMENT_FILE_TYPES = [10, 36];
 const MAJOR_VERSION_WP6_THROUGH_X6 = 2;
 function hasWordPerfectFileId(bytes) {
-	if (bytes.length < WPD_FILE_ID.length) return false;
 	return WPD_FILE_ID.every((expected, index) => bytes[index] === expected);
 }
 function readFileHeader(bytes, options = {}) {

package/dist/container/header.js

@@ -12,7 +12,6 @@ const PRODUCT_TYPE_WORDPERFECT = 1;
 const DOCUMENT_FILE_TYPES = [10, 36];
 const MAJOR_VERSION_WP6_THROUGH_X6 = 2;
 function hasWordPerfectFileId(bytes) {
-	if (bytes.length < WPD_FILE_ID.length) return false;
 	return WPD_FILE_ID.every((expected, index) => bytes[index] === expected);
 }
 function readFileHeader(bytes, options = {}) {

package/dist/container/prefix.cjs

@@ -52,24 +52,27 @@ const TYPEFACE_NAME_LENGTH_OFFSET = 22;
 const TYPEFACE_NAME_OFFSET = 24;
 const PACKET_TYPE_GENERAL_WP_TEXT = 8;
 function readGeneralWpTextBlocks(bytes) {
-	if (bytes.length < 4) return;
-	const blockCount = require_bytes_view.uint16At(bytes, 0);
-	const firstBlockOffset = require_bytes_view.uint16At(bytes, 2);
-	if (blockCount === 0) return;
-	if (4 + blockCount * 2 > bytes.length) return;
-	let totalSize = 0;
-	for (let index = 0; index < blockCount; index += 1) totalSize += require_bytes_view.uint16At(bytes, 4 + index * 2);
-	const end = firstBlockOffset + totalSize;
-	if (firstBlockOffset < 0 || end > bytes.length) return;
-	return bytes.subarray(firstBlockOffset, end);
+	try {
+		const blockCount = require_bytes_view.uint16At(bytes, 0);
+		const firstBlockOffset = require_bytes_view.uint16At(bytes, 2);
+		if (blockCount === 0) return;
+		let totalSize = 0;
+		for (let index = 0; index < blockCount; index += 1) totalSize += require_bytes_view.uint16At(bytes, 4 + index * 2);
+		const end = firstBlockOffset + totalSize;
+		if (end > bytes.length) return;
+		return bytes.subarray(firstBlockOffset, end);
+	} catch {
+		return;
+	}
 }
 function readTypefaceName(packet) {
-	if (packet.length < TYPEFACE_NAME_OFFSET) return;
-	const nameLength = require_bytes_view.uint16At(packet, TYPEFACE_NAME_LENGTH_OFFSET);
-	const available = Math.min(nameLength, packet.length - TYPEFACE_NAME_OFFSET);
-	if (available <= 0) return;
-	const { text } = require_stream_characters.decodeWordString(packet, TYPEFACE_NAME_OFFSET, Math.floor(available / 2));
-	return text.length > 0 ? text : void 0;
+	try {
+		const nameLength = require_bytes_view.uint16At(packet, TYPEFACE_NAME_LENGTH_OFFSET);
+		const { text } = require_stream_characters.decodeWordString(packet, TYPEFACE_NAME_OFFSET, Math.floor(nameLength / 2));
+		return text.length > 0 ? text : void 0;
+	} catch {
+		return;
+	}
 }
 //#endregion
 exports.PACKET_TYPE_DESIRED_FONT_DESCRIPTOR = PACKET_TYPE_DESIRED_FONT_DESCRIPTOR;

package/dist/container/prefix.js

@@ -51,24 +51,27 @@ const TYPEFACE_NAME_LENGTH_OFFSET = 22;
 const TYPEFACE_NAME_OFFSET = 24;
 const PACKET_TYPE_GENERAL_WP_TEXT = 8;
 function readGeneralWpTextBlocks(bytes) {
-	if (bytes.length < 4) return;
-	const blockCount = uint16At(bytes, 0);
-	const firstBlockOffset = uint16At(bytes, 2);
-	if (blockCount === 0) return;
-	if (4 + blockCount * 2 > bytes.length) return;
-	let totalSize = 0;
-	for (let index = 0; index < blockCount; index += 1) totalSize += uint16At(bytes, 4 + index * 2);
-	const end = firstBlockOffset + totalSize;
-	if (firstBlockOffset < 0 || end > bytes.length) return;
-	return bytes.subarray(firstBlockOffset, end);
+	try {
+		const blockCount = uint16At(bytes, 0);
+		const firstBlockOffset = uint16At(bytes, 2);
+		if (blockCount === 0) return;
+		let totalSize = 0;
+		for (let index = 0; index < blockCount; index += 1) totalSize += uint16At(bytes, 4 + index * 2);
+		const end = firstBlockOffset + totalSize;
+		if (end > bytes.length) return;
+		return bytes.subarray(firstBlockOffset, end);
+	} catch {
+		return;
+	}
 }
 function readTypefaceName(packet) {
-	if (packet.length < TYPEFACE_NAME_OFFSET) return;
-	const nameLength = uint16At(packet, TYPEFACE_NAME_LENGTH_OFFSET);
-	const available = Math.min(nameLength, packet.length - TYPEFACE_NAME_OFFSET);
-	if (available <= 0) return;
-	const { text } = decodeWordString(packet, TYPEFACE_NAME_OFFSET, Math.floor(available / 2));
-	return text.length > 0 ? text : void 0;
+	try {
+		const nameLength = uint16At(packet, TYPEFACE_NAME_LENGTH_OFFSET);
+		const { text } = decodeWordString(packet, TYPEFACE_NAME_OFFSET, Math.floor(nameLength / 2));
+		return text.length > 0 ? text : void 0;
+	} catch {
+		return;
+	}
 }
 //#endregion
 export { PACKET_TYPE_DESIRED_FONT_DESCRIPTOR, PACKET_TYPE_GENERAL_WP_TEXT, WPD_INDEX_RECORD_SIZE, packetByPrefixId, readGeneralWpTextBlocks, readPrefixPackets, readTypefaceName };

package/dist/container/summary.cjs

@@ -35,10 +35,16 @@ function readDocumentSummary(packet) {
 	const metadata = {};
 	let cursor = 0;
 	for (let group = 0; group < MAX_SUMMARY_GROUPS; group += 1) {
-		if (cursor + GROUP_HEADER_SIZE > packet.length) break;
-		const size = require_bytes_view.uint16At(packet, cursor);
-		const tag = require_bytes_view.uint16At(packet, cursor + 2);
-		const type = require_bytes_view.uint16At(packet, cursor + 4);
+		let size;
+		let tag;
+		let type;
+		try {
+			size = require_bytes_view.uint16At(packet, cursor);
+			tag = require_bytes_view.uint16At(packet, cursor + 2);
+			type = require_bytes_view.uint16At(packet, cursor + 4);
+		} catch {
+			break;
+		}
 		if (size < GROUP_HEADER_SIZE || cursor + size > packet.length) break;
 		const availableWords = Math.floor((size - GROUP_HEADER_SIZE) / 2);
 		const name = require_stream_characters.decodeWordString(packet, cursor + GROUP_HEADER_SIZE, availableWords);

package/dist/container/summary.js

@@ -34,10 +34,16 @@ function readDocumentSummary(packet) {
 	const metadata = {};
 	let cursor = 0;
 	for (let group = 0; group < MAX_SUMMARY_GROUPS; group += 1) {
-		if (cursor + GROUP_HEADER_SIZE > packet.length) break;
-		const size = uint16At(packet, cursor);
-		const tag = uint16At(packet, cursor + 2);
-		const type = uint16At(packet, cursor + 4);
+		let size;
+		let tag;
+		let type;
+		try {
+			size = uint16At(packet, cursor);
+			tag = uint16At(packet, cursor + 2);
+			type = uint16At(packet, cursor + 4);
+		} catch {
+			break;
+		}
 		if (size < GROUP_HEADER_SIZE || cursor + size > packet.length) break;
 		const availableWords = Math.floor((size - GROUP_HEADER_SIZE) / 2);
 		const name = decodeWordString(packet, cursor + GROUP_HEADER_SIZE, availableWords);

package/dist/read.cjs

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("./errors.cjs");
 const require_bytes_view = require("./bytes/view.cjs");
 const require_bytes_base64 = require("./bytes/base64.cjs");
 const require_stream_furniture = require("./stream/furniture.cjs");
@@ -87,6 +88,10 @@ function flushRun(state) {
 	state.runs.push(buildRun(state));
 	state.text = "";
 }
+const UNREACHABLE_CHARACTER_MAPPING_MESSAGE = "A single-byte document-area character had no character mapping, which the tokeniser's own byte range should make unreachable.";
+function assertDefined(value, message) {
+	if (value === void 0) throw new require_errors.WpdFormatError(message);
+}
 function targetBlocks(state) {
 	return state.table === void 0 ? state.blocks : state.table.cellBlocks;
 }
@@ -120,10 +125,7 @@ function flushParagraphIfContent(state, sink) {
 	flushParagraph(state, sink);
 }
 function effectiveStyle(state) {
-	for (let index = state.styleScopes.length - 1; index >= 0; index -= 1) {
-		const semantics = state.styleScopes[index]?.semantics;
-		if (semantics !== void 0) return semantics;
-	}
+	return state.styleScopes.findLast((scope) => scope.semantics !== void 0)?.semantics;
 }
 function appendText(state, text) {
 	if (state.skipDepth > 0 || state.numberDisplayDepth > 0) return;
@@ -272,7 +274,6 @@ function applySingleByteFunction(state, code, sink) {
 		case END_OF_TEXT_TO_SKIP:
 			state.skipDepth = Math.max(0, state.skipDepth - 1);
 			return;
-		default: return;
 	}
 }
 function applyFontFaceChange(state, prefixIds, container, sink) {
@@ -380,7 +381,7 @@ function applyStyleGroup(state, token, container, sink) {
 function applyDisplayNumberGroup(state, token, sink) {
 	if (require_stream_style.isParagraphNumberDisplayOn(token.subgroup)) {
 		const level = require_stream_style.readDisplayNumberLevel(token.nonDeletable);
-		if (level !== void 0 && state.pendingListLevel === void 0) state.pendingListLevel = level;
+		state.pendingListLevel ??= level;
 		state.numberDisplayDepth += 1;
 		reportOnce(state, sink, require_diagnostics.WpdDiagnosticCodes.OutlineNumberRegenerated, "An outline number's rendered digits were replaced by the list membership that regenerates them.");
 		return;
@@ -433,7 +434,6 @@ function applyCharacterGroup(state, token, container, sink) {
 			};
 			return;
 		}
-		default: return;
 	}
 }
 function applyHeaderFooterGroup(state, token, container, sink) {
@@ -749,7 +749,6 @@ function applyVariableFunction(state, token, container, sink) {
 		case BOX_GROUP:
 			applyBoxGroup(state, token, container, sink);
 			return;
-		default: return;
 	}
 }
 function applyFixedFunction(state, token, sink) {
@@ -785,14 +784,7 @@ function applyToken(state, token, container, sink) {
 	switch (token.kind) {
 		case "character": {
 			const character = require_stream_characters.decodeSingleByteCharacter(token.byte);
-			if (character === void 0) {
-				sink({
-					code: require_diagnostics.WpdDiagnosticCodes.UnmappedCharacter,
-					message: `Byte ${token.byte} in the document area has no character mapping and was rendered as U+FFFD.`
-				});
-				appendText(state, "�");
-				return;
-			}
+			assertDefined(character, UNREACHABLE_CHARACTER_MAPPING_MESSAGE);
 			appendText(state, character);
 			return;
 		}
@@ -934,7 +926,6 @@ function readWpd(bytes, options = {}) {
 		marker: note.marker,
 		blocks: note.blocks
 	}]));
-	if (Object.keys(attachments).length === 0 && notes.length === 0) return assembled;
 	return {
 		...assembled,
 		...Object.keys(attachments).length > 0 ? { attachments: {
@@ -948,5 +939,7 @@ function readWpd(bytes, options = {}) {
 	};
 }
 //#endregion
+exports.UNREACHABLE_CHARACTER_MAPPING_MESSAGE = UNREACHABLE_CHARACTER_MAPPING_MESSAGE;
+exports.assertDefined = assertDefined;
 exports.readWpd = readWpd;
 exports.readWpdContent = readWpdContent;

package/dist/read.d.cts

@@ -10,7 +10,9 @@ interface WpdNoteDefinition {
   readonly marker: string;
   readonly blocks: readonly ContentBlock[];
 }
+declare const UNREACHABLE_CHARACTER_MAPPING_MESSAGE = "A single-byte document-area character had no character mapping, which the tokeniser's own byte range should make unreachable.";
+declare function assertDefined<T>(value: T | undefined, message: string): asserts value is T;
 declare function readWpdContent(bytes: Uint8Array, options?: ReadWpdOptions): ContentDocument;
 declare function readWpd(bytes: Uint8Array, options?: ReadWpdOptions): DocumentTree;
 //#endregion
-export { ReadWpdOptions, WpdNoteDefinition, readWpd, readWpdContent };
+export { ReadWpdOptions, UNREACHABLE_CHARACTER_MAPPING_MESSAGE, WpdNoteDefinition, assertDefined, readWpd, readWpdContent };

package/dist/read.d.ts

@@ -10,7 +10,9 @@ interface WpdNoteDefinition {
   readonly marker: string;
   readonly blocks: readonly ContentBlock[];
 }
+declare const UNREACHABLE_CHARACTER_MAPPING_MESSAGE = "A single-byte document-area character had no character mapping, which the tokeniser's own byte range should make unreachable.";
+declare function assertDefined<T>(value: T | undefined, message: string): asserts value is T;
 declare function readWpdContent(bytes: Uint8Array, options?: ReadWpdOptions): ContentDocument;
 declare function readWpd(bytes: Uint8Array, options?: ReadWpdOptions): DocumentTree;
 //#endregion
-export { ReadWpdOptions, WpdNoteDefinition, readWpd, readWpdContent };
+export { ReadWpdOptions, UNREACHABLE_CHARACTER_MAPPING_MESSAGE, WpdNoteDefinition, assertDefined, readWpd, readWpdContent };

package/dist/read.js

@@ -1,3 +1,4 @@
+import { WpdFormatError } from "./errors.js";
 import { uint16At } from "./bytes/view.js";
 import { bytesToBase64 } from "./bytes/base64.js";
 import { readFurnitureClaim } from "./stream/furniture.js";
@@ -86,6 +87,10 @@ function flushRun(state) {
 	state.runs.push(buildRun(state));
 	state.text = "";
 }
+const UNREACHABLE_CHARACTER_MAPPING_MESSAGE = "A single-byte document-area character had no character mapping, which the tokeniser's own byte range should make unreachable.";
+function assertDefined(value, message) {
+	if (value === void 0) throw new WpdFormatError(message);
+}
 function targetBlocks(state) {
 	return state.table === void 0 ? state.blocks : state.table.cellBlocks;
 }
@@ -119,10 +124,7 @@ function flushParagraphIfContent(state, sink) {
 	flushParagraph(state, sink);
 }
 function effectiveStyle(state) {
-	for (let index = state.styleScopes.length - 1; index >= 0; index -= 1) {
-		const semantics = state.styleScopes[index]?.semantics;
-		if (semantics !== void 0) return semantics;
-	}
+	return state.styleScopes.findLast((scope) => scope.semantics !== void 0)?.semantics;
 }
 function appendText(state, text) {
 	if (state.skipDepth > 0 || state.numberDisplayDepth > 0) return;
@@ -271,7 +273,6 @@ function applySingleByteFunction(state, code, sink) {
 		case END_OF_TEXT_TO_SKIP:
 			state.skipDepth = Math.max(0, state.skipDepth - 1);
 			return;
-		default: return;
 	}
 }
 function applyFontFaceChange(state, prefixIds, container, sink) {
@@ -379,7 +380,7 @@ function applyStyleGroup(state, token, container, sink) {
 function applyDisplayNumberGroup(state, token, sink) {
 	if (isParagraphNumberDisplayOn(token.subgroup)) {
 		const level = readDisplayNumberLevel(token.nonDeletable);
-		if (level !== void 0 && state.pendingListLevel === void 0) state.pendingListLevel = level;
+		state.pendingListLevel ??= level;
 		state.numberDisplayDepth += 1;
 		reportOnce(state, sink, WpdDiagnosticCodes.OutlineNumberRegenerated, "An outline number's rendered digits were replaced by the list membership that regenerates them.");
 		return;
@@ -432,7 +433,6 @@ function applyCharacterGroup(state, token, container, sink) {
 			};
 			return;
 		}
-		default: return;
 	}
 }
 function applyHeaderFooterGroup(state, token, container, sink) {
@@ -748,7 +748,6 @@ function applyVariableFunction(state, token, container, sink) {
 		case BOX_GROUP:
 			applyBoxGroup(state, token, container, sink);
 			return;
-		default: return;
 	}
 }
 function applyFixedFunction(state, token, sink) {
@@ -784,14 +783,7 @@ function applyToken(state, token, container, sink) {
 	switch (token.kind) {
 		case "character": {
 			const character = decodeSingleByteCharacter(token.byte);
-			if (character === void 0) {
-				sink({
-					code: WpdDiagnosticCodes.UnmappedCharacter,
-					message: `Byte ${token.byte} in the document area has no character mapping and was rendered as U+FFFD.`
-				});
-				appendText(state, "�");
-				return;
-			}
+			assertDefined(character, UNREACHABLE_CHARACTER_MAPPING_MESSAGE);
 			appendText(state, character);
 			return;
 		}
@@ -933,7 +925,6 @@ function readWpd(bytes, options = {}) {
 		marker: note.marker,
 		blocks: note.blocks
 	}]));
-	if (Object.keys(attachments).length === 0 && notes.length === 0) return assembled;
 	return {
 		...assembled,
 		...Object.keys(attachments).length > 0 ? { attachments: {
@@ -947,4 +938,4 @@ function readWpd(bytes, options = {}) {
 	};
 }
 //#endregion
-export { readWpd, readWpdContent };
+export { UNREACHABLE_CHARACTER_MAPPING_MESSAGE, assertDefined, readWpd, readWpdContent };

package/dist/stream/box.cjs

@@ -8,83 +8,74 @@ const OVERRIDE_BIT_HTML = 7;
 const OVERRIDE_FLAGS_OFFSET = 18;
 const FIRST_OVERRIDE_BLOCK_OFFSET = 20;
 function walkOverrideBlocks(nonDeletable) {
-	if (nonDeletable.length < FIRST_OVERRIDE_BLOCK_OFFSET) return;
-	const flags = require_bytes_view.uint16At(nonDeletable, OVERRIDE_FLAGS_OFFSET);
-	const blocks = /* @__PURE__ */ new Map();
-	let cursor = FIRST_OVERRIDE_BLOCK_OFFSET;
-	for (let bit = 15; bit >= 5; bit -= 1) {
-		if ((flags & 1 << bit) === 0) continue;
-		if (bit === OVERRIDE_BIT_HTML) continue;
-		if (cursor + 2 > nonDeletable.length) return;
-		const size = require_bytes_view.uint16At(nonDeletable, cursor);
-		cursor += 2;
-		if (cursor + size > nonDeletable.length) return;
-		blocks.set(bit, nonDeletable.subarray(cursor, cursor + size));
-		cursor += size;
+	try {
+		const flags = require_bytes_view.uint16At(nonDeletable, OVERRIDE_FLAGS_OFFSET);
+		const blocks = /* @__PURE__ */ new Map();
+		let cursor = FIRST_OVERRIDE_BLOCK_OFFSET;
+		for (let bit = 15; bit >= 5; bit -= 1) {
+			if ((flags & 1 << bit) === 0) continue;
+			if (bit === OVERRIDE_BIT_HTML) continue;
+			const size = require_bytes_view.uint16At(nonDeletable, cursor);
+			cursor += 2;
+			if (cursor + size > nonDeletable.length) return;
+			blocks.set(bit, nonDeletable.subarray(cursor, cursor + size));
+			cursor += size;
+		}
+		return {
+			flags,
+			blocks
+		};
+	} catch {
+		return;
 	}
-	return {
-		flags,
-		blocks
-	};
 }
 function readContentType(contentBlock) {
-	if (contentBlock.length < 2) return;
-	const flags = require_bytes_view.uint16At(contentBlock, 0);
-	let cursor = 2;
-	if ((flags & 32768) !== 0) {
-		if (cursor + 2 > contentBlock.length) return;
-		cursor += 2;
+	try {
+		const flags = require_bytes_view.uint16At(contentBlock, 0);
+		let cursor = 2;
+		if ((flags & 32768) !== 0) cursor += 2;
+		if ((flags & 16384) === 0) return;
+		return contentBlock[cursor];
+	} catch {
+		return;
 	}
-	if ((flags & 16384) === 0) return;
-	return contentBlock[cursor];
 }
 function readPositionOverride(positionBlock) {
-	if (positionBlock.length < 2) return;
-	const flags = require_bytes_view.uint16At(positionBlock, 0);
-	let cursor = 2;
-	let widthWpu;
-	let heightWpu;
-	let xWpu;
-	let yWpu;
-	const need = (bytes) => cursor + bytes <= positionBlock.length;
-	if ((flags & 32768) !== 0) {
-		if (!need(2)) return void 0;
-		cursor += 2;
-	}
-	if ((flags & 16384) !== 0) {
-		if (!need(2)) return void 0;
-		cursor += 2;
-	}
-	if ((flags & 8192) !== 0) {
-		if (!need(5)) return void 0;
-		const horizontalFlags = positionBlock[cursor];
-		const offset = require_bytes_view.uint16At(positionBlock, cursor + 1);
-		if (horizontalFlags !== void 0 && (horizontalFlags & 3) === 0) xWpu = offset;
-		cursor += 5;
-	}
-	if ((flags & 4096) !== 0) {
-		if (!need(3)) return void 0;
-		const verticalFlags = positionBlock[cursor];
-		const offset = require_bytes_view.uint16At(positionBlock, cursor + 1);
-		if (verticalFlags !== void 0 && (verticalFlags & 3) === 0) yWpu = offset;
-		cursor += 3;
-	}
-	if ((flags & 2048) !== 0) {
-		if (!need(3)) return void 0;
-		widthWpu = require_bytes_view.uint16At(positionBlock, cursor + 1);
-		cursor += 3;
-	}
-	if ((flags & 1024) !== 0) {
-		if (!need(3)) return void 0;
-		heightWpu = require_bytes_view.uint16At(positionBlock, cursor + 1);
-		cursor += 3;
+	try {
+		const flags = require_bytes_view.uint16At(positionBlock, 0);
+		let cursor = 2;
+		let widthWpu;
+		let heightWpu;
+		let xWpu;
+		let yWpu;
+		if ((flags & 32768) !== 0) cursor += 2;
+		if ((flags & 16384) !== 0) cursor += 2;
+		if ((flags & 8192) !== 0) {
+			const horizontalFlags = positionBlock[cursor];
+			const offset = require_bytes_view.uint16At(positionBlock, cursor + 1);
+			if (horizontalFlags !== void 0 && (horizontalFlags & 3) === 0) xWpu = offset;
+			cursor += 5;
+		}
+		if ((flags & 4096) !== 0) {
+			const verticalFlags = positionBlock[cursor];
+			const offset = require_bytes_view.uint16At(positionBlock, cursor + 1);
+			if (verticalFlags !== void 0 && (verticalFlags & 3) === 0) yWpu = offset;
+			cursor += 3;
+		}
+		if ((flags & 2048) !== 0) {
+			widthWpu = require_bytes_view.uint16At(positionBlock, cursor + 1);
+			cursor += 3;
+		}
+		if ((flags & 1024) !== 0) heightWpu = require_bytes_view.uint16At(positionBlock, cursor + 1);
+		return {
+			widthWpu,
+			heightWpu,
+			xWpu,
+			yWpu
+		};
+	} catch {
+		return;
 	}
-	return {
-		widthWpu,
-		heightWpu,
-		xWpu,
-		yWpu
-	};
 }
 const BOX_CONTENT_TYPE_TEXT = 1;
 const BOX_CONTENT_TYPE_LINKED_TEXT = 2;