js.documents 12.1.0 → 14.0.0

package/dist/svg/text.d.cts

@@ -1,8 +1,30 @@
+import { TextEncodingLabel, UndecodableTextError } from "byte-codec";
 //#region src/svg/text.d.ts
-declare class SvgInvalidUtf8Error extends Error {
-  constructor();
+/** Thrown when an SVG document's own `<?xml ... encoding="..."?>` declaration names an encoding outside byte-codec's own bounded decodeText set: a legacy CJK or Cyrillic code page, or a name this package does not recognise as an alias of one of the six it does support (ExaDev/documents.js#1361). */
+declare class SvgUnsupportedEncodingError extends Error {
+  /** The declaration's own raw label, exactly as written in the document. */
+  readonly label: string;
+  constructor(label: string);
 }
+/** Thrown when svg bytes cannot be decoded as text under the encoding that settled it: a byte order mark or an `<?xml ...?>` declaration named one the bytes then contradict, or, with neither present, the bytes are not well-formed UTF-8, XML's own default. */
+declare class SvgUndecodableTextError extends Error {
+  /** The encoding the bytes were decoded against and failed. */
+  readonly encoding: TextEncodingLabel;
+  constructor(encoding: TextEncodingLabel, cause: UndecodableTextError);
+}
+/**
+ * Decodes svg bytes to text, honouring the encoding a byte order mark or an `<?xml ...?>` declaration names and defaulting to strict UTF-8, XML's own default, when neither is present.
+ * @param bytes - The svg bytes.
+ * @throws SvgUnsupportedEncodingError When the declaration names an encoding outside byte-codec's own bounded set.
+ * @throws SvgUndecodableTextError When the bytes contradict the encoding that settled them.
+ * @returns The svg text.
+ */
 declare function decodeSvgText(bytes: Uint8Array): string;
+/**
+ * Encodes svg text as UTF-8 bytes, with no `<?xml ...?>` declaration of its own.
+ * @param text - The svg text.
+ * @returns The UTF-8 bytes. A byte stream with no declaration and no byte order mark is UTF-8 under XML's own default, so {@link decodeSvgText} reads it back correctly without one.
+ */
 declare function encodeSvgText(text: string): Uint8Array<ArrayBuffer>;
 //#endregion
-export { SvgInvalidUtf8Error, decodeSvgText, encodeSvgText };
+export { SvgUndecodableTextError, SvgUnsupportedEncodingError, decodeSvgText, encodeSvgText };

package/dist/svg/text.d.ts

@@ -1,8 +1,30 @@
+import { TextEncodingLabel, UndecodableTextError } from "byte-codec";
 //#region src/svg/text.d.ts
-declare class SvgInvalidUtf8Error extends Error {
-  constructor();
+/** Thrown when an SVG document's own `<?xml ... encoding="..."?>` declaration names an encoding outside byte-codec's own bounded decodeText set: a legacy CJK or Cyrillic code page, or a name this package does not recognise as an alias of one of the six it does support (ExaDev/documents.js#1361). */
+declare class SvgUnsupportedEncodingError extends Error {
+  /** The declaration's own raw label, exactly as written in the document. */
+  readonly label: string;
+  constructor(label: string);
 }
+/** Thrown when svg bytes cannot be decoded as text under the encoding that settled it: a byte order mark or an `<?xml ...?>` declaration named one the bytes then contradict, or, with neither present, the bytes are not well-formed UTF-8, XML's own default. */
+declare class SvgUndecodableTextError extends Error {
+  /** The encoding the bytes were decoded against and failed. */
+  readonly encoding: TextEncodingLabel;
+  constructor(encoding: TextEncodingLabel, cause: UndecodableTextError);
+}
+/**
+ * Decodes svg bytes to text, honouring the encoding a byte order mark or an `<?xml ...?>` declaration names and defaulting to strict UTF-8, XML's own default, when neither is present.
+ * @param bytes - The svg bytes.
+ * @throws SvgUnsupportedEncodingError When the declaration names an encoding outside byte-codec's own bounded set.
+ * @throws SvgUndecodableTextError When the bytes contradict the encoding that settled them.
+ * @returns The svg text.
+ */
 declare function decodeSvgText(bytes: Uint8Array): string;
+/**
+ * Encodes svg text as UTF-8 bytes, with no `<?xml ...?>` declaration of its own.
+ * @param text - The svg text.
+ * @returns The UTF-8 bytes. A byte stream with no declaration and no byte order mark is UTF-8 under XML's own default, so {@link decodeSvgText} reads it back correctly without one.
+ */
 declare function encodeSvgText(text: string): Uint8Array<ArrayBuffer>;
 //#endregion
-export { SvgInvalidUtf8Error, decodeSvgText, encodeSvgText };
+export { SvgUndecodableTextError, SvgUnsupportedEncodingError, decodeSvgText, encodeSvgText };

package/dist/svg/text.js

@@ -1,19 +1,51 @@
+import { detectSvgEncoding } from "./xml-encoding.js";
+import { UndecodableTextError, decodeText } from "byte-codec";
 //#region src/svg/text.ts
-var SvgInvalidUtf8Error = class extends Error {
-	constructor() {
-		super("svg text must be well-formed UTF-8");
-		this.name = "SvgInvalidUtf8Error";
+/** Thrown when an SVG document's own `<?xml ... encoding="..."?>` declaration names an encoding outside byte-codec's own bounded decodeText set: a legacy CJK or Cyrillic code page, or a name this package does not recognise as an alias of one of the six it does support (ExaDev/documents.js#1361). */
+var SvgUnsupportedEncodingError = class extends Error {
+	/** The declaration's own raw label, exactly as written in the document. */
+	label;
+	constructor(label) {
+		super(`svg declares an encoding this package cannot decode: "${label}" (ExaDev/documents.js#1361)`);
+		this.name = "SvgUnsupportedEncodingError";
+		this.label = label;
 	}
 };
+/** Thrown when svg bytes cannot be decoded as text under the encoding that settled it: a byte order mark or an `<?xml ...?>` declaration named one the bytes then contradict, or, with neither present, the bytes are not well-formed UTF-8, XML's own default. */
+var SvgUndecodableTextError = class extends Error {
+	/** The encoding the bytes were decoded against and failed. */
+	encoding;
+	constructor(encoding, cause) {
+		super(`svg bytes are not well-formed ${encoding}: ${cause.message}`, { cause });
+		this.name = "SvgUndecodableTextError";
+		this.encoding = encoding;
+	}
+};
+/**
+* Decodes svg bytes to text, honouring the encoding a byte order mark or an `<?xml ...?>` declaration names and defaulting to strict UTF-8, XML's own default, when neither is present.
+* @param bytes - The svg bytes.
+* @throws SvgUnsupportedEncodingError When the declaration names an encoding outside byte-codec's own bounded set.
+* @throws SvgUndecodableTextError When the bytes contradict the encoding that settled them.
+* @returns The svg text.
+*/
 function decodeSvgText(bytes) {
+	const detected = detectSvgEncoding(bytes);
+	if (detected?.kind === "unsupported") throw new SvgUnsupportedEncodingError(detected.label);
+	const encoding = detected?.encoding ?? "utf-8";
 	try {
-		return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-	} catch {
-		throw new SvgInvalidUtf8Error();
+		return decodeText(bytes, { encoding }).text;
+	} catch (error) {
+		if (error instanceof UndecodableTextError) throw new SvgUndecodableTextError(encoding, error);
+		throw error;
 	}
 }
+/**
+* Encodes svg text as UTF-8 bytes, with no `<?xml ...?>` declaration of its own.
+* @param text - The svg text.
+* @returns The UTF-8 bytes. A byte stream with no declaration and no byte order mark is UTF-8 under XML's own default, so {@link decodeSvgText} reads it back correctly without one.
+*/
 function encodeSvgText(text) {
 	return new TextEncoder().encode(text);
 }
 //#endregion
-export { SvgInvalidUtf8Error, decodeSvgText, encodeSvgText };
+export { SvgUndecodableTextError, SvgUnsupportedEncodingError, decodeSvgText, encodeSvgText };

package/dist/svg/xml-encoding.cjs

@@ -0,0 +1,91 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let byte_codec = require("byte-codec");
+//#region src/svg/xml-encoding.ts
+const XML_ENCODING_ALIASES = {
+	"utf-8": "utf-8",
+	utf8: "utf-8",
+	"unicode-1-1-utf-8": "utf-8",
+	unicode11utf8: "utf-8",
+	unicode20utf8: "utf-8",
+	"x-unicode20utf8": "utf-8",
+	"utf-16le": "utf-16le",
+	"utf-16": "utf-16le",
+	"ucs-2": "utf-16le",
+	unicode: "utf-16le",
+	unicodefeff: "utf-16le",
+	csunicode: "utf-16le",
+	"iso-10646-ucs-2": "utf-16le",
+	"utf-16be": "utf-16be",
+	unicodefffe: "utf-16be",
+	"utf-32le": "utf-32le",
+	"utf-32be": "utf-32be",
+	"windows-1252": "windows-1252",
+	cp1252: "windows-1252",
+	"x-cp1252": "windows-1252",
+	"iso-8859-1": "windows-1252",
+	"iso8859-1": "windows-1252",
+	"iso_8859-1": "windows-1252",
+	"iso_8859-1:1987": "windows-1252",
+	"iso-ir-100": "windows-1252",
+	csisolatin1: "windows-1252",
+	l1: "windows-1252",
+	latin1: "windows-1252",
+	cp819: "windows-1252",
+	ibm819: "windows-1252",
+	"us-ascii": "windows-1252",
+	ascii: "windows-1252",
+	"ansi_x3.4-1968": "windows-1252"
+};
+/**
+* Maps a name from an XML encoding declaration onto the encoding byte-codec's decodeText would decode it under, matched case-insensitively against the WHATWG Encoding Standard's own label table (restricted to the six encodings decodeText supports).
+* @param label - The declaration's raw `encoding` value, exactly as written.
+* @returns The matching {@link TextEncodingLabel}, or `undefined` when the name is outside decodeText's own bounded set (ExaDev/documents.js#1361).
+*/
+function mapXmlEncodingLabel(label) {
+	return XML_ENCODING_ALIASES[label.toLowerCase()];
+}
+const XML_DECLARATION_SEARCH_WINDOW = 512;
+const XML_DECLARATION_START = "<?xml";
+const XML_ENCODING_DECL_PATTERN = /\bencoding\s*=\s*(["'])([A-Za-z][A-Za-z0-9._-]*)\1/;
+/**
+* Reads the raw encoding label out of an `<?xml ...?>` declaration's own leading bytes, without decoding anything.
+*
+* Safe ahead of any real decode because the declaration's own grammar restricts every character in it to ASCII: XML mandates that a declaration, if present, start at the very first byte (a byte order mark aside), so bytes not beginning with the literal ASCII sequence `<?xml` carry no declaration to read, and bytes that do keep writing ASCII up to and including the encoding name itself, whatever that name turns out to be.
+* @param bytes - The document's own leading bytes.
+* @returns The declaration's raw `encoding` value, exactly as written, or `undefined` when the leading bytes carry no `<?xml ...?>` declaration, or that declaration names no encoding.
+*/
+function readXmlEncodingDeclarationLabel(bytes) {
+	const windowLength = Math.min(bytes.length, XML_DECLARATION_SEARCH_WINDOW);
+	let window = "";
+	for (let index = 0; index < windowLength; index += 1) window += String.fromCharCode(bytes[index]);
+	if (!window.startsWith(XML_DECLARATION_START)) return;
+	const declarationEnd = window.indexOf("?>");
+	const declaration = declarationEnd === -1 ? window : window.slice(0, declarationEnd);
+	return XML_ENCODING_DECL_PATTERN.exec(declaration)?.[2];
+}
+/**
+* Detects the encoding SVG's own XML prolog declares, per XML 1.0's own external-encoding-detection algorithm: a byte order mark first, since it needs no decoding to trust, then the `<?xml ... encoding="..."?>` declaration.
+* @param bytes - The document's own leading bytes.
+* @returns How the encoding was settled, or `undefined` when the leading bytes carry neither a byte order mark nor a declared encoding. XML's own default of UTF-8 applies in that case, left for the caller to decode strictly rather than through decodeText's own guessing.
+*/
+function detectSvgEncoding(bytes) {
+	const bom = (0, byte_codec.detectByteOrderMark)(bytes);
+	if (bom !== void 0) return {
+		kind: "resolved",
+		encoding: bom.encoding
+	};
+	const label = readXmlEncodingDeclarationLabel(bytes);
+	if (label === void 0) return;
+	const encoding = mapXmlEncodingLabel(label);
+	return encoding === void 0 ? {
+		kind: "unsupported",
+		label
+	} : {
+		kind: "resolved",
+		encoding
+	};
+}
+//#endregion
+exports.detectSvgEncoding = detectSvgEncoding;
+exports.mapXmlEncodingLabel = mapXmlEncodingLabel;
+exports.readXmlEncodingDeclarationLabel = readXmlEncodingDeclarationLabel;

package/dist/svg/xml-encoding.d.cts

@@ -0,0 +1,32 @@
+import { TextEncodingLabel } from "byte-codec";
+//#region src/svg/xml-encoding.d.ts
+/**
+ * Maps a name from an XML encoding declaration onto the encoding byte-codec's decodeText would decode it under, matched case-insensitively against the WHATWG Encoding Standard's own label table (restricted to the six encodings decodeText supports).
+ * @param label - The declaration's raw `encoding` value, exactly as written.
+ * @returns The matching {@link TextEncodingLabel}, or `undefined` when the name is outside decodeText's own bounded set (ExaDev/documents.js#1361).
+ */
+declare function mapXmlEncodingLabel(label: string): TextEncodingLabel | undefined;
+/**
+ * Reads the raw encoding label out of an `<?xml ...?>` declaration's own leading bytes, without decoding anything.
+ *
+ * Safe ahead of any real decode because the declaration's own grammar restricts every character in it to ASCII: XML mandates that a declaration, if present, start at the very first byte (a byte order mark aside), so bytes not beginning with the literal ASCII sequence `<?xml` carry no declaration to read, and bytes that do keep writing ASCII up to and including the encoding name itself, whatever that name turns out to be.
+ * @param bytes - The document's own leading bytes.
+ * @returns The declaration's raw `encoding` value, exactly as written, or `undefined` when the leading bytes carry no `<?xml ...?>` declaration, or that declaration names no encoding.
+ */
+declare function readXmlEncodingDeclarationLabel(bytes: Uint8Array): string | undefined;
+/** How {@link detectSvgEncoding} settled the encoding: `resolved` when a byte order mark or a declaration named one decodeText can decode, `unsupported` when a declaration named something outside decodeText's own bounded set. */
+type SvgEncodingDetection = {
+  readonly kind: "resolved";
+  readonly encoding: TextEncodingLabel;
+} | {
+  readonly kind: "unsupported";
+  readonly label: string;
+};
+/**
+ * Detects the encoding SVG's own XML prolog declares, per XML 1.0's own external-encoding-detection algorithm: a byte order mark first, since it needs no decoding to trust, then the `<?xml ... encoding="..."?>` declaration.
+ * @param bytes - The document's own leading bytes.
+ * @returns How the encoding was settled, or `undefined` when the leading bytes carry neither a byte order mark nor a declared encoding. XML's own default of UTF-8 applies in that case, left for the caller to decode strictly rather than through decodeText's own guessing.
+ */
+declare function detectSvgEncoding(bytes: Uint8Array): SvgEncodingDetection | undefined;
+//#endregion
+export { SvgEncodingDetection, detectSvgEncoding, mapXmlEncodingLabel, readXmlEncodingDeclarationLabel };

package/dist/svg/xml-encoding.d.ts

@@ -0,0 +1,32 @@
+import { TextEncodingLabel } from "byte-codec";
+//#region src/svg/xml-encoding.d.ts
+/**
+ * Maps a name from an XML encoding declaration onto the encoding byte-codec's decodeText would decode it under, matched case-insensitively against the WHATWG Encoding Standard's own label table (restricted to the six encodings decodeText supports).
+ * @param label - The declaration's raw `encoding` value, exactly as written.
+ * @returns The matching {@link TextEncodingLabel}, or `undefined` when the name is outside decodeText's own bounded set (ExaDev/documents.js#1361).
+ */
+declare function mapXmlEncodingLabel(label: string): TextEncodingLabel | undefined;
+/**
+ * Reads the raw encoding label out of an `<?xml ...?>` declaration's own leading bytes, without decoding anything.
+ *
+ * Safe ahead of any real decode because the declaration's own grammar restricts every character in it to ASCII: XML mandates that a declaration, if present, start at the very first byte (a byte order mark aside), so bytes not beginning with the literal ASCII sequence `<?xml` carry no declaration to read, and bytes that do keep writing ASCII up to and including the encoding name itself, whatever that name turns out to be.
+ * @param bytes - The document's own leading bytes.
+ * @returns The declaration's raw `encoding` value, exactly as written, or `undefined` when the leading bytes carry no `<?xml ...?>` declaration, or that declaration names no encoding.
+ */
+declare function readXmlEncodingDeclarationLabel(bytes: Uint8Array): string | undefined;
+/** How {@link detectSvgEncoding} settled the encoding: `resolved` when a byte order mark or a declaration named one decodeText can decode, `unsupported` when a declaration named something outside decodeText's own bounded set. */
+type SvgEncodingDetection = {
+  readonly kind: "resolved";
+  readonly encoding: TextEncodingLabel;
+} | {
+  readonly kind: "unsupported";
+  readonly label: string;
+};
+/**
+ * Detects the encoding SVG's own XML prolog declares, per XML 1.0's own external-encoding-detection algorithm: a byte order mark first, since it needs no decoding to trust, then the `<?xml ... encoding="..."?>` declaration.
+ * @param bytes - The document's own leading bytes.
+ * @returns How the encoding was settled, or `undefined` when the leading bytes carry neither a byte order mark nor a declared encoding. XML's own default of UTF-8 applies in that case, left for the caller to decode strictly rather than through decodeText's own guessing.
+ */
+declare function detectSvgEncoding(bytes: Uint8Array): SvgEncodingDetection | undefined;
+//#endregion
+export { SvgEncodingDetection, detectSvgEncoding, mapXmlEncodingLabel, readXmlEncodingDeclarationLabel };

package/dist/svg/xml-encoding.js

@@ -0,0 +1,88 @@
+import { detectByteOrderMark } from "byte-codec";
+//#region src/svg/xml-encoding.ts
+const XML_ENCODING_ALIASES = {
+	"utf-8": "utf-8",
+	utf8: "utf-8",
+	"unicode-1-1-utf-8": "utf-8",
+	unicode11utf8: "utf-8",
+	unicode20utf8: "utf-8",
+	"x-unicode20utf8": "utf-8",
+	"utf-16le": "utf-16le",
+	"utf-16": "utf-16le",
+	"ucs-2": "utf-16le",
+	unicode: "utf-16le",
+	unicodefeff: "utf-16le",
+	csunicode: "utf-16le",
+	"iso-10646-ucs-2": "utf-16le",
+	"utf-16be": "utf-16be",
+	unicodefffe: "utf-16be",
+	"utf-32le": "utf-32le",
+	"utf-32be": "utf-32be",
+	"windows-1252": "windows-1252",
+	cp1252: "windows-1252",
+	"x-cp1252": "windows-1252",
+	"iso-8859-1": "windows-1252",
+	"iso8859-1": "windows-1252",
+	"iso_8859-1": "windows-1252",
+	"iso_8859-1:1987": "windows-1252",
+	"iso-ir-100": "windows-1252",
+	csisolatin1: "windows-1252",
+	l1: "windows-1252",
+	latin1: "windows-1252",
+	cp819: "windows-1252",
+	ibm819: "windows-1252",
+	"us-ascii": "windows-1252",
+	ascii: "windows-1252",
+	"ansi_x3.4-1968": "windows-1252"
+};
+/**
+* Maps a name from an XML encoding declaration onto the encoding byte-codec's decodeText would decode it under, matched case-insensitively against the WHATWG Encoding Standard's own label table (restricted to the six encodings decodeText supports).
+* @param label - The declaration's raw `encoding` value, exactly as written.
+* @returns The matching {@link TextEncodingLabel}, or `undefined` when the name is outside decodeText's own bounded set (ExaDev/documents.js#1361).
+*/
+function mapXmlEncodingLabel(label) {
+	return XML_ENCODING_ALIASES[label.toLowerCase()];
+}
+const XML_DECLARATION_SEARCH_WINDOW = 512;
+const XML_DECLARATION_START = "<?xml";
+const XML_ENCODING_DECL_PATTERN = /\bencoding\s*=\s*(["'])([A-Za-z][A-Za-z0-9._-]*)\1/;
+/**
+* Reads the raw encoding label out of an `<?xml ...?>` declaration's own leading bytes, without decoding anything.
+*
+* Safe ahead of any real decode because the declaration's own grammar restricts every character in it to ASCII: XML mandates that a declaration, if present, start at the very first byte (a byte order mark aside), so bytes not beginning with the literal ASCII sequence `<?xml` carry no declaration to read, and bytes that do keep writing ASCII up to and including the encoding name itself, whatever that name turns out to be.
+* @param bytes - The document's own leading bytes.
+* @returns The declaration's raw `encoding` value, exactly as written, or `undefined` when the leading bytes carry no `<?xml ...?>` declaration, or that declaration names no encoding.
+*/
+function readXmlEncodingDeclarationLabel(bytes) {
+	const windowLength = Math.min(bytes.length, XML_DECLARATION_SEARCH_WINDOW);
+	let window = "";
+	for (let index = 0; index < windowLength; index += 1) window += String.fromCharCode(bytes[index]);
+	if (!window.startsWith(XML_DECLARATION_START)) return;
+	const declarationEnd = window.indexOf("?>");
+	const declaration = declarationEnd === -1 ? window : window.slice(0, declarationEnd);
+	return XML_ENCODING_DECL_PATTERN.exec(declaration)?.[2];
+}
+/**
+* Detects the encoding SVG's own XML prolog declares, per XML 1.0's own external-encoding-detection algorithm: a byte order mark first, since it needs no decoding to trust, then the `<?xml ... encoding="..."?>` declaration.
+* @param bytes - The document's own leading bytes.
+* @returns How the encoding was settled, or `undefined` when the leading bytes carry neither a byte order mark nor a declared encoding. XML's own default of UTF-8 applies in that case, left for the caller to decode strictly rather than through decodeText's own guessing.
+*/
+function detectSvgEncoding(bytes) {
+	const bom = detectByteOrderMark(bytes);
+	if (bom !== void 0) return {
+		kind: "resolved",
+		encoding: bom.encoding
+	};
+	const label = readXmlEncodingDeclarationLabel(bytes);
+	if (label === void 0) return;
+	const encoding = mapXmlEncodingLabel(label);
+	return encoding === void 0 ? {
+		kind: "unsupported",
+		label
+	} : {
+		kind: "resolved",
+		encoding
+	};
+}
+//#endregion
+export { detectSvgEncoding, mapXmlEncodingLabel, readXmlEncodingDeclarationLabel };

package/dist/{table-BT3wN3Hd.d.cts → table-Bt9ahRyh.d.cts}

@@ -60,6 +60,8 @@ declare class OdtTable {
   constructor(container: XmlNode[], node: XmlElement, pkg: Package);
   private live;
   rows(): OdtTableRow[];
+  headerRows(): boolean[];
+  setHeaderRows(flags: readonly boolean[]): void;
   gridRows(): TableGridRows<OdtTableCell>;
   gridColumnCount(): number;
   private grid;

package/dist/{table-DhTy5Re7.d.ts → table-Cou5rKOo.d.ts}

@@ -60,6 +60,8 @@ declare class OdtTable {
   constructor(container: XmlNode[], node: XmlElement, pkg: Package);
   private live;
   rows(): OdtTableRow[];
+  headerRows(): boolean[];
+  setHeaderRows(flags: readonly boolean[]): void;
   gridRows(): TableGridRows<OdtTableCell>;
   gridColumnCount(): number;
   private grid;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js.documents",
-  "version": "12.1.0",
+  "version": "14.0.0",
   "description": "Bidirectional docx/pptx <-> PDF conversion and a read+write editable OOXML document model, built on ooxml.js and Zod 4 codecs.",
   "type": "module",
   "repository": {
@@ -77,21 +77,21 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "archive-codec": "1.11.9",
-    "byte-codec": "1.7.0",
-    "doc-codec": "5.0.0",
-    "document-schema.js": "7.13.0",
-    "epub-codec": "4.0.0",
+    "archive-codec": "1.11.10",
+    "byte-codec": "1.8.0",
+    "doc-codec": "6.0.0",
+    "document-schema.js": "7.14.0",
+    "epub-codec": "5.0.0",
     "fflate": "0.8.3",
-    "markdown-codec": "10.0.0",
-    "odf.js": "10.0.0",
-    "ooxml.js": "11.1.0",
-    "pdf-codec": "5.2.3",
-    "ppt-codec": "2.0.4",
-    "rtf-codec": "7.0.0",
+    "markdown-codec": "11.0.0",
+    "odf.js": "11.0.0",
+    "ooxml.js": "12.0.0",
+    "pdf-codec": "5.2.4",
+    "ppt-codec": "2.1.0",
+    "rtf-codec": "8.0.0",
     "temml": "0.13.4",
-    "wpd-codec": "5.0.2",
-    "xls-codec": "4.15.15",
+    "wpd-codec": "5.1.0",
+    "xls-codec": "4.15.16",
     "zod": "4.4.3"
   },
   "devDependencies": {