documents.js 1.61.0 → 1.63.0

package/dist/firebird/data.js

@@ -25,23 +25,71 @@ var FirebirdCompositeRecordUnsupportedError = class extends Error {
 		this.recordType = recordType;
 	}
 };
-function skipBlobRecord(reader) {
-	let segmentCount;
+function readBlobRecord(reader) {
+	const ATT_BLOB_FIELD_NUMBER = 3;
+	const ATT_BLOB_NUMBER_SEGMENTS = 5;
+	const ATT_BLOB_DATA = 7;
+	let fieldNumber;
+	let segmentCount = 0;
 	for (;;) {
 		const attribute = reader.readTag();
-		if (attribute === 0) break;
-		if (attribute === 5) segmentCount = reader.readInt32Attribute();
-		else if (attribute === 7) {
-			const count = segmentCount ?? 0;
-			for (let i = 0; i < count; i++) {
-				const length = reader.readBlobSegmentLength();
-				reader.readRawPayload(length);
-			}
-		} else reader.skipAttributeValue();
+		if (attribute === ATT_BLOB_DATA) break;
+		if (attribute === ATT_BLOB_FIELD_NUMBER) fieldNumber = reader.readInt32Attribute();
+		else if (attribute === ATT_BLOB_NUMBER_SEGMENTS) segmentCount = reader.readInt32Attribute();
+		else reader.skipAttributeValue();
+	}
+	if (fieldNumber === void 0) throw new FirebirdDataParseError("a rec_blob record had no att_blob_field_number attribute, so its content cannot be attributed to a column");
+	const segments = [];
+	let total = 0;
+	for (let i = 0; i < segmentCount; i++) {
+		const length = reader.readBlobSegmentLength();
+		const segment = reader.readRawPayload(length);
+		segments.push(segment);
+		total += segment.length;
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const segment of segments) {
+		bytes.set(segment, offset);
+		offset += segment.length;
 	}
+	return {
+		fieldNumber,
+		bytes
+	};
+}
+const BINARY_BLOB_DATA_URI_PREFIX = "data:application/octet-stream;base64,";
+const BLOB_SUB_TYPE_TEXT = 1;
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+	let result = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const b0 = bytes[i] ?? 0;
+		const b1 = bytes[i + 1];
+		const b2 = bytes[i + 2];
+		const triple = b0 << 16 | (b1 ?? 0) << 8 | (b2 ?? 0);
+		result += BASE64_ALPHABET[triple >> 18 & 63] ?? "";
+		result += BASE64_ALPHABET[triple >> 12 & 63] ?? "";
+		result += b1 === void 0 ? "=" : BASE64_ALPHABET[triple >> 6 & 63] ?? "";
+		result += b2 === void 0 ? "=" : BASE64_ALPHABET[triple & 63] ?? "";
+	}
+	return result;
+}
+function blobCellValue(field, bytes) {
+	if (field.subType === BLOB_SUB_TYPE_TEXT) return {
+		kind: "string",
+		value: new TextDecoder("utf-8").decode(bytes)
+	};
+	return {
+		kind: "string",
+		value: `${BINARY_BLOB_DATA_URI_PREFIX}${bytesToBase64(bytes)}`
+	};
+}
+function storedFieldsOf(fields) {
+	return fields.filter((field) => !field.computed);
 }
 function decodeRowValues(fields, payload) {
-	const storedFields = fields.filter((field) => !field.computed);
+	const storedFields = storedFieldsOf(fields);
 	const xdr = new XdrReader(payload);
 	const rawValues = [];
 	for (const field of storedFields) switch (field.physicalType) {
@@ -170,10 +218,16 @@ function readRowGroup(reader, relation, compressed) {
 			if (dataTag !== ATT_DATA_DATA) throw new FirebirdDataParseError(`relation "${relation.name}": expected att_data_data (tag ${ATT_DATA_DATA}), found tag ${dataTag}`);
 		}
 		const payload = compressed ? reader.readCompressedPayload(xdrLength) : reader.readRawPayload(xdrLength);
-		rows.push(decodeRowValues(relation.fields, payload));
+		const values = decodeRowValues(relation.fields, payload);
+		rows.push(values);
 		let next = reader.readTag();
 		while (next === REC_BLOB) {
-			skipBlobRecord(reader);
+			const blob = readBlobRecord(reader);
+			const storedFields = storedFieldsOf(relation.fields);
+			const columnIndex = storedFields.findIndex((field) => field.fieldNumber === blob.fieldNumber);
+			const field = storedFields[columnIndex];
+			if (field === void 0) throw new FirebirdDataParseError(`relation "${relation.name}": a rec_blob record names att_blob_field_number ${blob.fieldNumber}, which matches no field's own att_field_number in this relation`);
+			values[columnIndex] = blobCellValue(field, blob.bytes);
 			next = reader.readTag();
 		}
 		if (next !== REC_DATA) {

package/dist/firebird/schema.cjs

@@ -12,8 +12,10 @@ var FirebirdSchemaParseError = class extends Error {
 const ATT_RELATION_NAME = 1;
 const ATT_FIELD_NAME = 1;
 const ATT_FIELD_TYPE = 8;
+const ATT_FIELD_SUB_TYPE = 9;
 const ATT_FIELD_LENGTH = 10;
 const ATT_FIELD_SCALE = 11;
+const ATT_FIELD_NUMBER = 22;
 const ATT_FIELD_COMPUTED_FLAG = 23;
 const ATT_FIELD_CHARACTER_LENGTH = 41;
 function readField(reader) {
@@ -22,6 +24,8 @@ function readField(reader) {
 	let lengthBytes = 0;
 	let scale = 0;
 	let characterLength;
+	let subType = 0;
+	let fieldNumber;
 	let computed = false;
 	for (;;) {
 		const attribute = reader.readTag();
@@ -33,9 +37,15 @@ function readField(reader) {
 			case ATT_FIELD_TYPE:
 				blrType = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_SUB_TYPE:
+				subType = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_LENGTH:
 				lengthBytes = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_NUMBER:
+				fieldNumber = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_SCALE:
 				scale = reader.readInt32Attribute();
 				break;
@@ -51,13 +61,15 @@ function readField(reader) {
 	if (name === void 0) throw new FirebirdSchemaParseError("a rec_field record had no att_field_name attribute");
 	if (blrType === void 0) throw new FirebirdSchemaParseError(`field "${name}" had no att_field_type attribute`);
 	const physicalType = require_firebird_blr_types.decodeBlrType(blrType);
-	const typeLabel = require_firebird_blr_types.describeFieldType(physicalType, lengthBytes, scale, characterLength);
+	const typeLabel = require_firebird_blr_types.describeFieldType(physicalType, lengthBytes, scale, characterLength, subType);
 	return {
 		name,
 		physicalType,
 		lengthBytes,
 		scale,
 		characterLength,
+		subType,
+		fieldNumber,
 		typeLabel,
 		computed
 	};

package/dist/firebird/schema.d.cts

@@ -1,2 +1,2 @@
-import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-Acco3Ezi.cjs";
+import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-BeR_KJ0X.cjs";
 export { FirebirdField, FirebirdRelation, FirebirdSchemaParseError, readRelationSchema };

package/dist/firebird/schema.d.ts

@@ -1,2 +1,2 @@
-import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-VkAA6pF5.js";
+import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-CSKwSb_v.js";
 export { FirebirdField, FirebirdRelation, FirebirdSchemaParseError, readRelationSchema };

package/dist/firebird/schema.js

@@ -11,8 +11,10 @@ var FirebirdSchemaParseError = class extends Error {
 const ATT_RELATION_NAME = 1;
 const ATT_FIELD_NAME = 1;
 const ATT_FIELD_TYPE = 8;
+const ATT_FIELD_SUB_TYPE = 9;
 const ATT_FIELD_LENGTH = 10;
 const ATT_FIELD_SCALE = 11;
+const ATT_FIELD_NUMBER = 22;
 const ATT_FIELD_COMPUTED_FLAG = 23;
 const ATT_FIELD_CHARACTER_LENGTH = 41;
 function readField(reader) {
@@ -21,6 +23,8 @@ function readField(reader) {
 	let lengthBytes = 0;
 	let scale = 0;
 	let characterLength;
+	let subType = 0;
+	let fieldNumber;
 	let computed = false;
 	for (;;) {
 		const attribute = reader.readTag();
@@ -32,9 +36,15 @@ function readField(reader) {
 			case ATT_FIELD_TYPE:
 				blrType = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_SUB_TYPE:
+				subType = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_LENGTH:
 				lengthBytes = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_NUMBER:
+				fieldNumber = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_SCALE:
 				scale = reader.readInt32Attribute();
 				break;
@@ -50,13 +60,15 @@ function readField(reader) {
 	if (name === void 0) throw new FirebirdSchemaParseError("a rec_field record had no att_field_name attribute");
 	if (blrType === void 0) throw new FirebirdSchemaParseError(`field "${name}" had no att_field_type attribute`);
 	const physicalType = decodeBlrType(blrType);
-	const typeLabel = describeFieldType(physicalType, lengthBytes, scale, characterLength);
+	const typeLabel = describeFieldType(physicalType, lengthBytes, scale, characterLength, subType);
 	return {
 		name,
 		physicalType,
 		lengthBytes,
 		scale,
 		characterLength,
+		subType,
+		fieldNumber,
 		typeLabel,
 		computed
 	};

package/dist/fonts/obfuscation.cjs

@@ -0,0 +1,50 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let pdf_codec_sfnt = require("pdf-codec/sfnt");
+//#region src/fonts/obfuscation.ts
+const FONT_KEY_HEX_LENGTH = 32;
+const FONT_KEY_BYTE_LENGTH = 16;
+const OBFUSCATED_PREFIX_LENGTH = 32;
+const SFNT_HEADER_LENGTH = 12;
+const HEX_PAIR_PATTERN = /^[0-9A-Fa-f]{2}$/;
+var FontDeobfuscationError = class extends Error {
+	constructor(detail) {
+		super(`deobfuscateEmbeddedFont: ${detail}`);
+		this.name = "FontDeobfuscationError";
+	}
+};
+function deriveFontKey(fontKey) {
+	const hex = fontKey.replace(/[{}-]/g, "");
+	if (hex.length !== FONT_KEY_HEX_LENGTH) throw new FontDeobfuscationError(`w:fontKey ${JSON.stringify(fontKey)} has ${String(hex.length)} hex digit(s) after stripping braces and hyphens, expected ${String(FONT_KEY_HEX_LENGTH)}`);
+	const key = new Uint8Array(FONT_KEY_BYTE_LENGTH);
+	for (let i = 0; i < FONT_KEY_BYTE_LENGTH; i++) {
+		const start = 30 - i * 2;
+		const pair = hex.slice(start, start + 2);
+		if (!HEX_PAIR_PATTERN.test(pair)) throw new FontDeobfuscationError(`w:fontKey ${JSON.stringify(fontKey)} contains the non-hexadecimal pair ${JSON.stringify(pair)}`);
+		key[i] = Number.parseInt(pair, 16);
+	}
+	return key;
+}
+function looksLikeSfnt(bytes) {
+	return bytes.length >= SFNT_HEADER_LENGTH && (0, pdf_codec_sfnt.parseSfnt)(bytes) !== void 0;
+}
+function deobfuscateEmbeddedFont(bytes, fontKey) {
+	if (looksLikeSfnt(bytes)) return bytes;
+	if (fontKey === void 0) throw new FontDeobfuscationError("the part does not begin with an sfnt signature and carries no font key to deobfuscate it with");
+	if (bytes.length < OBFUSCATED_PREFIX_LENGTH) throw new FontDeobfuscationError(`an obfuscated part must be at least ${String(OBFUSCATED_PREFIX_LENGTH)} bytes long, got ${String(bytes.length)}`);
+	const key = deriveFontKey(fontKey);
+	const clear = new Uint8Array(bytes.length);
+	clear.set(bytes);
+	for (let i = 0; i < OBFUSCATED_PREFIX_LENGTH; i++) {
+		const keyByte = key[i % FONT_KEY_BYTE_LENGTH];
+		const cipherByte = clear[i];
+		if (keyByte === void 0 || cipherByte === void 0) throw new FontDeobfuscationError(`byte ${String(i)} of the obfuscated prefix is out of range`);
+		clear[i] = cipherByte ^ keyByte;
+	}
+	if (!looksLikeSfnt(clear)) throw new FontDeobfuscationError(`deobfuscating with font key ${JSON.stringify(fontKey)} did not produce a recognisable sfnt font`);
+	return clear;
+}
+//#endregion
+exports.FontDeobfuscationError = FontDeobfuscationError;
+exports.deobfuscateEmbeddedFont = deobfuscateEmbeddedFont;
+exports.deriveFontKey = deriveFontKey;
+exports.looksLikeSfnt = looksLikeSfnt;

package/dist/fonts/obfuscation.d.cts

@@ -0,0 +1,9 @@
+//#region src/fonts/obfuscation.d.ts
+declare class FontDeobfuscationError extends Error {
+  constructor(detail: string);
+}
+declare function deriveFontKey(fontKey: string): Uint8Array<ArrayBuffer>;
+declare function looksLikeSfnt(bytes: Uint8Array<ArrayBuffer>): boolean;
+declare function deobfuscateEmbeddedFont(bytes: Uint8Array<ArrayBuffer>, fontKey: string | undefined): Uint8Array<ArrayBuffer>;
+//#endregion
+export { FontDeobfuscationError, deobfuscateEmbeddedFont, deriveFontKey, looksLikeSfnt };

package/dist/fonts/obfuscation.d.ts

@@ -0,0 +1,9 @@
+//#region src/fonts/obfuscation.d.ts
+declare class FontDeobfuscationError extends Error {
+  constructor(detail: string);
+}
+declare function deriveFontKey(fontKey: string): Uint8Array<ArrayBuffer>;
+declare function looksLikeSfnt(bytes: Uint8Array<ArrayBuffer>): boolean;
+declare function deobfuscateEmbeddedFont(bytes: Uint8Array<ArrayBuffer>, fontKey: string | undefined): Uint8Array<ArrayBuffer>;
+//#endregion
+export { FontDeobfuscationError, deobfuscateEmbeddedFont, deriveFontKey, looksLikeSfnt };

package/dist/fonts/obfuscation.js

@@ -0,0 +1,46 @@
+import { parseSfnt } from "pdf-codec/sfnt";
+//#region src/fonts/obfuscation.ts
+const FONT_KEY_HEX_LENGTH = 32;
+const FONT_KEY_BYTE_LENGTH = 16;
+const OBFUSCATED_PREFIX_LENGTH = 32;
+const SFNT_HEADER_LENGTH = 12;
+const HEX_PAIR_PATTERN = /^[0-9A-Fa-f]{2}$/;
+var FontDeobfuscationError = class extends Error {
+	constructor(detail) {
+		super(`deobfuscateEmbeddedFont: ${detail}`);
+		this.name = "FontDeobfuscationError";
+	}
+};
+function deriveFontKey(fontKey) {
+	const hex = fontKey.replace(/[{}-]/g, "");
+	if (hex.length !== FONT_KEY_HEX_LENGTH) throw new FontDeobfuscationError(`w:fontKey ${JSON.stringify(fontKey)} has ${String(hex.length)} hex digit(s) after stripping braces and hyphens, expected ${String(FONT_KEY_HEX_LENGTH)}`);
+	const key = new Uint8Array(FONT_KEY_BYTE_LENGTH);
+	for (let i = 0; i < FONT_KEY_BYTE_LENGTH; i++) {
+		const start = 30 - i * 2;
+		const pair = hex.slice(start, start + 2);
+		if (!HEX_PAIR_PATTERN.test(pair)) throw new FontDeobfuscationError(`w:fontKey ${JSON.stringify(fontKey)} contains the non-hexadecimal pair ${JSON.stringify(pair)}`);
+		key[i] = Number.parseInt(pair, 16);
+	}
+	return key;
+}
+function looksLikeSfnt(bytes) {
+	return bytes.length >= SFNT_HEADER_LENGTH && parseSfnt(bytes) !== void 0;
+}
+function deobfuscateEmbeddedFont(bytes, fontKey) {
+	if (looksLikeSfnt(bytes)) return bytes;
+	if (fontKey === void 0) throw new FontDeobfuscationError("the part does not begin with an sfnt signature and carries no font key to deobfuscate it with");
+	if (bytes.length < OBFUSCATED_PREFIX_LENGTH) throw new FontDeobfuscationError(`an obfuscated part must be at least ${String(OBFUSCATED_PREFIX_LENGTH)} bytes long, got ${String(bytes.length)}`);
+	const key = deriveFontKey(fontKey);
+	const clear = new Uint8Array(bytes.length);
+	clear.set(bytes);
+	for (let i = 0; i < OBFUSCATED_PREFIX_LENGTH; i++) {
+		const keyByte = key[i % FONT_KEY_BYTE_LENGTH];
+		const cipherByte = clear[i];
+		if (keyByte === void 0 || cipherByte === void 0) throw new FontDeobfuscationError(`byte ${String(i)} of the obfuscated prefix is out of range`);
+		clear[i] = cipherByte ^ keyByte;
+	}
+	if (!looksLikeSfnt(clear)) throw new FontDeobfuscationError(`deobfuscating with font key ${JSON.stringify(fontKey)} did not produce a recognisable sfnt font`);
+	return clear;
+}
+//#endregion
+export { FontDeobfuscationError, deobfuscateEmbeddedFont, deriveFontKey, looksLikeSfnt };

package/dist/fonts/odf.cjs

@@ -0,0 +1,86 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fonts_obfuscation = require("./obfuscation.cjs");
+let odf_js = require("odf.js");
+let pdf_codec_sfnt = require("pdf-codec/sfnt");
+let pdf_codec_font_tables = require("pdf-codec/font-tables");
+//#region src/fonts/odf.ts
+const FONT_FACE_DECL_PARTS = ["content.xml", "styles.xml"];
+const FS_SELECTION_ITALIC = 1;
+const FS_SELECTION_BOLD = 32;
+const BOLD_WEIGHT_THRESHOLD = 600;
+var OdfEmbeddedFontError = class extends Error {
+	constructor(detail) {
+		super(`extractOdfEmbeddedFonts: ${detail}`);
+		this.name = "OdfEmbeddedFontError";
+	}
+};
+function normaliseFamily(value) {
+	const first = (0, odf_js.decodeXmlText)(value).split(",")[0]?.trim() ?? "";
+	const quoted = /^'(.*)'$|^"(.*)"$/.exec(first);
+	return (quoted?.[1] ?? quoted?.[2] ?? first).trim();
+}
+function boldFromWeightAttribute(weight) {
+	const keyword = weight.trim().toLowerCase();
+	if (keyword === "bold" || keyword === "bolder") return true;
+	if (keyword === "normal" || keyword === "lighter") return false;
+	const numeric = Number.parseInt(keyword, 10);
+	return Number.isNaN(numeric) ? void 0 : numeric >= BOLD_WEIGHT_THRESHOLD;
+}
+function italicFromStyleAttribute(style) {
+	const keyword = style.trim().toLowerCase();
+	if (keyword === "italic" || keyword === "oblique") return true;
+	return keyword === "normal" ? false : void 0;
+}
+function styleFromFontBytes(bytes) {
+	const font = (0, pdf_codec_sfnt.parseSfnt)(bytes);
+	if (font === void 0) return;
+	const os2 = (0, pdf_codec_font_tables.parseOs2)(font);
+	if (os2 === void 0) return;
+	return {
+		bold: (os2.fsSelection & FS_SELECTION_BOLD) !== 0,
+		italic: (os2.fsSelection & FS_SELECTION_ITALIC) !== 0
+	};
+}
+function fontPartBytes(pkg, href) {
+	const part = pkg.parts[href];
+	if (part === void 0) throw new OdfEmbeddedFontError(`svg:font-face-uri references ${JSON.stringify(href)}, which is not a part of this package`);
+	if (part.kind !== "binary") throw new OdfEmbeddedFontError(`embedded font part ${JSON.stringify(href)} is an XML part, not binary font data`);
+	return (0, odf_js.base64ToBytes)(part.base64);
+}
+function collectFontFace(pkg, fontFace, seenHrefs, out) {
+	const declaredFamily = (0, odf_js.attrValue)(fontFace, "svg:font-family") ?? (0, odf_js.attrValue)(fontFace, "style:name");
+	for (const src of (0, odf_js.childrenWithTag)(fontFace, "svg:font-face-src")) for (const uri of (0, odf_js.childrenWithTag)(src, "svg:font-face-uri")) {
+		const rawHref = (0, odf_js.attrValue)(uri, "xlink:href");
+		if (rawHref === void 0) throw new OdfEmbeddedFontError("a <svg:font-face-uri> carries no xlink:href");
+		const href = (0, odf_js.decodeXmlText)(rawHref);
+		if (seenHrefs.has(href)) continue;
+		seenHrefs.add(href);
+		if (declaredFamily === void 0) throw new OdfEmbeddedFontError(`the <style:font-face> embedding ${JSON.stringify(href)} declares neither svg:font-family nor style:name`);
+		const bytes = fontPartBytes(pkg, href);
+		if (!require_fonts_obfuscation.looksLikeSfnt(bytes)) throw new OdfEmbeddedFontError(`embedded font part ${JSON.stringify(href)} does not begin with a recognisable sfnt signature`);
+		const declaredWeight = (0, odf_js.attrValue)(uri, "loext:font-weight");
+		const declaredStyle = (0, odf_js.attrValue)(uri, "loext:font-style");
+		const intrinsic = styleFromFontBytes(bytes);
+		out.push({
+			family: normaliseFamily(declaredFamily),
+			bold: (declaredWeight === void 0 ? void 0 : boldFromWeightAttribute(declaredWeight)) ?? intrinsic?.bold ?? false,
+			italic: (declaredStyle === void 0 ? void 0 : italicFromStyleAttribute(declaredStyle)) ?? intrinsic?.italic ?? false,
+			bytes
+		});
+	}
+}
+function extractOdfEmbeddedFonts(pkg) {
+	const out = [];
+	const seenHrefs = /* @__PURE__ */ new Set();
+	for (const partPath of FONT_FACE_DECL_PARTS) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") continue;
+		const root = (0, odf_js.rootElement)(part.nodes);
+		if (root === void 0) continue;
+		for (const decls of (0, odf_js.childrenWithTag)(root, "office:font-face-decls")) for (const fontFace of (0, odf_js.childrenWithTag)(decls, "style:font-face")) collectFontFace(pkg, fontFace, seenHrefs, out);
+	}
+	return out;
+}
+//#endregion
+exports.OdfEmbeddedFontError = OdfEmbeddedFontError;
+exports.extractOdfEmbeddedFonts = extractOdfEmbeddedFonts;

package/dist/fonts/odf.d.cts

@@ -0,0 +1,9 @@
+import { Package } from "odf.js";
+import { ProvidedFont } from "pdf-codec";
+//#region src/fonts/odf.d.ts
+declare class OdfEmbeddedFontError extends Error {
+  constructor(detail: string);
+}
+declare function extractOdfEmbeddedFonts(pkg: Package): ProvidedFont[];
+//#endregion
+export { OdfEmbeddedFontError, extractOdfEmbeddedFonts };

package/dist/fonts/odf.d.ts

@@ -0,0 +1,9 @@
+import { Package } from "odf.js";
+import { ProvidedFont } from "pdf-codec";
+//#region src/fonts/odf.d.ts
+declare class OdfEmbeddedFontError extends Error {
+  constructor(detail: string);
+}
+declare function extractOdfEmbeddedFonts(pkg: Package): ProvidedFont[];
+//#endregion
+export { OdfEmbeddedFontError, extractOdfEmbeddedFonts };

package/dist/fonts/odf.js

@@ -0,0 +1,84 @@
+import { looksLikeSfnt } from "./obfuscation.js";
+import { attrValue, base64ToBytes, childrenWithTag, decodeXmlText, rootElement } from "odf.js";
+import { parseSfnt } from "pdf-codec/sfnt";
+import { parseOs2 } from "pdf-codec/font-tables";
+//#region src/fonts/odf.ts
+const FONT_FACE_DECL_PARTS = ["content.xml", "styles.xml"];
+const FS_SELECTION_ITALIC = 1;
+const FS_SELECTION_BOLD = 32;
+const BOLD_WEIGHT_THRESHOLD = 600;
+var OdfEmbeddedFontError = class extends Error {
+	constructor(detail) {
+		super(`extractOdfEmbeddedFonts: ${detail}`);
+		this.name = "OdfEmbeddedFontError";
+	}
+};
+function normaliseFamily(value) {
+	const first = decodeXmlText(value).split(",")[0]?.trim() ?? "";
+	const quoted = /^'(.*)'$|^"(.*)"$/.exec(first);
+	return (quoted?.[1] ?? quoted?.[2] ?? first).trim();
+}
+function boldFromWeightAttribute(weight) {
+	const keyword = weight.trim().toLowerCase();
+	if (keyword === "bold" || keyword === "bolder") return true;
+	if (keyword === "normal" || keyword === "lighter") return false;
+	const numeric = Number.parseInt(keyword, 10);
+	return Number.isNaN(numeric) ? void 0 : numeric >= BOLD_WEIGHT_THRESHOLD;
+}
+function italicFromStyleAttribute(style) {
+	const keyword = style.trim().toLowerCase();
+	if (keyword === "italic" || keyword === "oblique") return true;
+	return keyword === "normal" ? false : void 0;
+}
+function styleFromFontBytes(bytes) {
+	const font = parseSfnt(bytes);
+	if (font === void 0) return;
+	const os2 = parseOs2(font);
+	if (os2 === void 0) return;
+	return {
+		bold: (os2.fsSelection & FS_SELECTION_BOLD) !== 0,
+		italic: (os2.fsSelection & FS_SELECTION_ITALIC) !== 0
+	};
+}
+function fontPartBytes(pkg, href) {
+	const part = pkg.parts[href];
+	if (part === void 0) throw new OdfEmbeddedFontError(`svg:font-face-uri references ${JSON.stringify(href)}, which is not a part of this package`);
+	if (part.kind !== "binary") throw new OdfEmbeddedFontError(`embedded font part ${JSON.stringify(href)} is an XML part, not binary font data`);
+	return base64ToBytes(part.base64);
+}
+function collectFontFace(pkg, fontFace, seenHrefs, out) {
+	const declaredFamily = attrValue(fontFace, "svg:font-family") ?? attrValue(fontFace, "style:name");
+	for (const src of childrenWithTag(fontFace, "svg:font-face-src")) for (const uri of childrenWithTag(src, "svg:font-face-uri")) {
+		const rawHref = attrValue(uri, "xlink:href");
+		if (rawHref === void 0) throw new OdfEmbeddedFontError("a <svg:font-face-uri> carries no xlink:href");
+		const href = decodeXmlText(rawHref);
+		if (seenHrefs.has(href)) continue;
+		seenHrefs.add(href);
+		if (declaredFamily === void 0) throw new OdfEmbeddedFontError(`the <style:font-face> embedding ${JSON.stringify(href)} declares neither svg:font-family nor style:name`);
+		const bytes = fontPartBytes(pkg, href);
+		if (!looksLikeSfnt(bytes)) throw new OdfEmbeddedFontError(`embedded font part ${JSON.stringify(href)} does not begin with a recognisable sfnt signature`);
+		const declaredWeight = attrValue(uri, "loext:font-weight");
+		const declaredStyle = attrValue(uri, "loext:font-style");
+		const intrinsic = styleFromFontBytes(bytes);
+		out.push({
+			family: normaliseFamily(declaredFamily),
+			bold: (declaredWeight === void 0 ? void 0 : boldFromWeightAttribute(declaredWeight)) ?? intrinsic?.bold ?? false,
+			italic: (declaredStyle === void 0 ? void 0 : italicFromStyleAttribute(declaredStyle)) ?? intrinsic?.italic ?? false,
+			bytes
+		});
+	}
+}
+function extractOdfEmbeddedFonts(pkg) {
+	const out = [];
+	const seenHrefs = /* @__PURE__ */ new Set();
+	for (const partPath of FONT_FACE_DECL_PARTS) {
+		const part = pkg.parts[partPath];
+		if (part?.kind !== "xml") continue;
+		const root = rootElement(part.nodes);
+		if (root === void 0) continue;
+		for (const decls of childrenWithTag(root, "office:font-face-decls")) for (const fontFace of childrenWithTag(decls, "style:font-face")) collectFontFace(pkg, fontFace, seenHrefs, out);
+	}
+	return out;
+}
+//#endregion
+export { OdfEmbeddedFontError, extractOdfEmbeddedFonts };

package/dist/fonts/ooxml.cjs

@@ -0,0 +1,129 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fonts_obfuscation = require("./obfuscation.cjs");
+let ooxml_js = require("ooxml.js");
+//#region src/fonts/ooxml.ts
+const OFFICE_DOCUMENT_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument";
+const FONT_TABLE_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable";
+const ROOT_RELS_PART = "_rels/.rels";
+const DOCX_EMBED_ELEMENTS = [
+	[
+		"w:embedRegular",
+		false,
+		false
+	],
+	[
+		"w:embedBold",
+		true,
+		false
+	],
+	[
+		"w:embedItalic",
+		false,
+		true
+	],
+	[
+		"w:embedBoldItalic",
+		true,
+		true
+	]
+];
+const PPTX_EMBED_ELEMENTS = [
+	[
+		"p:regular",
+		false,
+		false
+	],
+	[
+		"p:bold",
+		true,
+		false
+	],
+	[
+		"p:italic",
+		false,
+		true
+	],
+	[
+		"p:boldItalic",
+		true,
+		true
+	]
+];
+var OoxmlEmbeddedFontError = class extends Error {
+	constructor(detail) {
+		super(`extractOoxmlEmbeddedFonts: ${detail}`);
+		this.name = "OoxmlEmbeddedFontError";
+	}
+};
+function relatedPartPath(pkg, fromPartPath, relationshipType) {
+	for (const relationship of (0, ooxml_js.resolveRelationships)(pkg, fromPartPath).values()) if (relationship.type === relationshipType && relationship.targetMode === void 0) return relationship.target;
+}
+function officeDocumentPartPath(pkg) {
+	const rels = (0, ooxml_js.rootElement)(pkg.parts[ROOT_RELS_PART]);
+	if (rels !== void 0) for (const relationship of (0, ooxml_js.childrenWithTag)(rels, "Relationship")) {
+		if ((0, ooxml_js.attr)(relationship, "Type") !== OFFICE_DOCUMENT_RELATIONSHIP || (0, ooxml_js.attr)(relationship, "TargetMode") !== void 0) continue;
+		const target = (0, ooxml_js.attr)(relationship, "Target");
+		if (target !== void 0) return target.startsWith("/") ? target.slice(1) : target;
+	}
+	throw new OoxmlEmbeddedFontError(`the package declares no officeDocument relationship in ${ROOT_RELS_PART}`);
+}
+function fontPartBytes(pkg, fromPartPath, relationships, relationshipId) {
+	const relationship = relationships.get(relationshipId);
+	if (relationship === void 0) throw new OoxmlEmbeddedFontError(`${fromPartPath} references relationship id ${JSON.stringify(relationshipId)}, which its .rels part does not declare`);
+	const part = pkg.parts[relationship.target];
+	if (part === void 0) throw new OoxmlEmbeddedFontError(`relationship id ${JSON.stringify(relationshipId)} targets ${JSON.stringify(relationship.target)}, which is not a part of this package`);
+	if (part.kind !== "binary") throw new OoxmlEmbeddedFontError(`embedded font part ${JSON.stringify(relationship.target)} is an XML part, not binary font data`);
+	return (0, ooxml_js.base64ToBytes)(part.base64);
+}
+function collectFaces(pkg, declaringPartPath, relationships, fontElementChildren, fontElement, family, fontKeyAttribute, out) {
+	for (const [tag, bold, italic] of fontElementChildren) for (const embed of (0, ooxml_js.childrenWithTag)(fontElement, tag)) {
+		const relationshipId = (0, ooxml_js.attr)(embed, "r:id");
+		if (relationshipId === void 0) throw new OoxmlEmbeddedFontError(`<${tag}> for font ${JSON.stringify(family)} carries no r:id`);
+		const fontKey = fontKeyAttribute === void 0 ? void 0 : (0, ooxml_js.attr)(embed, fontKeyAttribute);
+		out.push({
+			family,
+			bold,
+			italic,
+			bytes: require_fonts_obfuscation.deobfuscateEmbeddedFont(fontPartBytes(pkg, declaringPartPath, relationships, relationshipId), fontKey)
+		});
+	}
+}
+function extractDocxFonts(pkg) {
+	const fontTablePath = relatedPartPath(pkg, officeDocumentPartPath(pkg), FONT_TABLE_RELATIONSHIP);
+	if (fontTablePath === void 0) return [];
+	const fontTablePart = pkg.parts[fontTablePath];
+	if (fontTablePart?.kind !== "xml") throw new OoxmlEmbeddedFontError(`font table part ${JSON.stringify(fontTablePath)} is missing or is not an XML part`);
+	const fonts = (0, ooxml_js.rootElement)(fontTablePart);
+	if (fonts === void 0) return [];
+	const relationships = (0, ooxml_js.resolveRelationships)(pkg, fontTablePath);
+	const out = [];
+	for (const font of (0, ooxml_js.childrenWithTag)(fonts, "w:font")) {
+		const family = (0, ooxml_js.attr)(font, "w:name");
+		if (family === void 0) throw new OoxmlEmbeddedFontError(`a <w:font> in ${JSON.stringify(fontTablePath)} carries no w:name`);
+		collectFaces(pkg, fontTablePath, relationships, DOCX_EMBED_ELEMENTS, font, (0, ooxml_js.decodeEntities)(family), "w:fontKey", out);
+	}
+	return out;
+}
+function extractPptxFonts(pkg) {
+	const presentationPartPath = officeDocumentPartPath(pkg);
+	const presentationPart = pkg.parts[presentationPartPath];
+	if (presentationPart?.kind !== "xml") throw new OoxmlEmbeddedFontError(`presentation part ${JSON.stringify(presentationPartPath)} is missing or is not an XML part`);
+	const presentation = (0, ooxml_js.rootElement)(presentationPart);
+	if (presentation === void 0) return [];
+	const relationships = (0, ooxml_js.resolveRelationships)(pkg, presentationPartPath);
+	const out = [];
+	for (const list of (0, ooxml_js.childrenWithTag)(presentation, "p:embeddedFontLst")) for (const embeddedFont of (0, ooxml_js.childrenWithTag)(list, "p:embeddedFont")) {
+		const fontElement = (0, ooxml_js.childrenWithTag)(embeddedFont, "p:font")[0];
+		if (fontElement === void 0) throw new OoxmlEmbeddedFontError(`a <p:embeddedFont> in ${JSON.stringify(presentationPartPath)} carries no <p:font>`);
+		const family = (0, ooxml_js.attr)(fontElement, "typeface");
+		if (family === void 0) throw new OoxmlEmbeddedFontError(`a <p:font> in ${JSON.stringify(presentationPartPath)} carries no typeface`);
+		collectFaces(pkg, presentationPartPath, relationships, PPTX_EMBED_ELEMENTS, embeddedFont, (0, ooxml_js.decodeEntities)(family), void 0, out);
+	}
+	return out;
+}
+function extractOoxmlEmbeddedFonts(pkg, kind) {
+	return kind === "docx" ? extractDocxFonts(pkg) : extractPptxFonts(pkg);
+}
+//#endregion
+exports.OoxmlEmbeddedFontError = OoxmlEmbeddedFontError;
+exports.extractOoxmlEmbeddedFonts = extractOoxmlEmbeddedFonts;