documents.js 1.51.0 → 1.53.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { AttributeSchema, BinaryPartSchema, CommentSchema, CompactPackageSchema, CompactPartSchema, CompactXmlNodeSchema, DefinedNameSchema, PackageSchema, PartSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, attr, attr as attr$1, base64ToBytes, base64ToBytes as base64ToBytes$1, buildXlsxPackage, buildXml, bytesToBase64, bytesToBase64 as bytesToBase64$1, childrenWithTag, compactCodec, compactPackageCodec, decodeCompactPackage, decodeEntities, decodePackage, decodePackage as decodePackage$1, elementsWithTag, elementsWithTag as elementsWithTag$1, encodeCompactPackage, encodePackage, encodePackage as encodePackage$1, fromCompact, isCompactXmlNode, isXmlNode, packageCodec, parsePackage, parseXml, readDocx, readPptx, readXlsxContent, resolveRelationships, resolveRelationships as resolveRelationships$1, rootElement, rootElement as rootElement$1, serializePackage, textContent as textContent$1, textContent as textContent$2, toCompact, unzipPackage, walk, xmlCodec, zipPackage } from "ooxml.js";
-import { COLOR_BLACK, COLOR_BLACK as COLOR_BLACK$1, ContentBlockSchema, ContentCellValueSchema, ContentDrawPageSchema, ContentDrawPageSchema as ContentDrawPageSchema$1, ContentImageBlockSchema, ContentPageBreakSchema, ContentParagraphSchema, ContentPathPointSchema, ContentPathSegmentSchema, ContentRunSchema, ContentSectionSchema, ContentSectionSchema as ContentSectionSchema$1, ContentShapeSchema, ContentSheetCellSchema, ContentSheetColumnSchema, ContentSheetPrintRangeSchema, ContentSheetPrintSettingsSchema, ContentSheetRepeatRangeSchema, ContentSheetRowSchema, ContentSheetSchema, ContentSheetSchema as ContentSheetSchema$1, ContentSlideSchema, ContentSlideSchema as ContentSlideSchema$1, ContentStrokeSchema, ContentSubpathSchema, ContentTableCellSchema, ContentTableRowSchema, ContentTableSchema, ContentVectorSchema, DEFAULT_LAYOUT_FONT, LAYOUT_FORMAT_VERSION, LAYOUT_FORMAT_VERSION as LAYOUT_FORMAT_VERSION$1, LayoutDocumentSchema, LayoutMetadataSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, colorToRgbHex, isContentBlock, rgbHexToColor } from "document-content-model";
+import { COLOR_BLACK, COLOR_BLACK as COLOR_BLACK$1, ContentBlockSchema, ContentCellValueSchema, ContentDrawPageSchema, ContentDrawPageSchema as ContentDrawPageSchema$1, ContentImageBlockSchema, ContentPageBreakSchema, ContentParagraphSchema, ContentPathPointSchema, ContentPathSegmentSchema, ContentRunSchema, ContentSectionSchema, ContentSectionSchema as ContentSectionSchema$1, ContentShapeSchema, ContentSheetCellSchema, ContentSheetColumnSchema, ContentSheetPrintRangeSchema, ContentSheetPrintSettingsSchema, ContentSheetRepeatRangeSchema, ContentSheetRowSchema, ContentSheetSchema, ContentSheetSchema as ContentSheetSchema$1, ContentSlideSchema, ContentSlideSchema as ContentSlideSchema$1, ContentStrokeSchema, ContentSubpathSchema, ContentTableCellSchema, ContentTableRowSchema, ContentTableSchema, ContentVectorSchema, DEFAULT_LAYOUT_FONT, DOCUMENT_PACKAGE_FORMAT_VERSION, LAYOUT_FORMAT_VERSION, LAYOUT_FORMAT_VERSION as LAYOUT_FORMAT_VERSION$1, LayoutDocumentSchema, LayoutMetadataSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, colorToRgbHex, isContentBlock, rgbHexToColor } from "document-content-model";
 import { z } from "zod";
 import { ODF_MEDIA_TYPES, StyleRegistry, applyOdfTransform, attrValue, base64ToBytes as base64ToBytes$2, buildOdfSubpaths, bytesToBase64 as bytesToBase64$2, childrenWithTag as childrenWithTag$1, decodeOdfText, decodePackage as decodePackage$2, encodePackage as encodePackage$2, findChildElement, findStyleElement, formatOdfColor, formatOdfLength, parseBox, parseCellReference, parseLinePoints, parseMargins, parseOdfColor, parseOdfLength, parseOdfPathData, parseOdfViewBox, parsePageSize, readDrawFrame, readManifest, readOdbInventory, readOdfFormula, readOdfMetadata, readOdfParagraph, readOdfTable, readOdg, readOdm, readOdp, readOds, readOdt, resolveOdfShapeGeometry, resolvePageLayoutProperties, resolveStyle, rootElement as rootElement$2, setDocumentMediaType, syncManifest, syncManifest as syncManifest$1, xmlnsAttributes } from "odf.js";
 import { Unzlib, inflateSync, unzlibSync, zlibSync } from "fflate";
@@ -9210,12 +9210,12 @@ function textToPdfString(text) {
 	}
 	return pdfHexString(bytes);
 }
-function pad2(n) {
+function pad2$2(n) {
 	return n.toString().padStart(2, "0");
 }
 function formatPdfDate(iso) {
 	const date = new Date(iso);
-	return `D:${date.getUTCFullYear()}${pad2(date.getUTCMonth() + 1)}${pad2(date.getUTCDate())}${pad2(date.getUTCHours())}${pad2(date.getUTCMinutes())}${pad2(date.getUTCSeconds())}Z`;
+	return `D:${date.getUTCFullYear()}${pad2$2(date.getUTCMonth() + 1)}${pad2$2(date.getUTCDate())}${pad2$2(date.getUTCHours())}${pad2$2(date.getUTCMinutes())}${pad2$2(date.getUTCSeconds())}Z`;
 }
 function buildInfoDict(doc) {
 	const entries = /* @__PURE__ */ new Map();
@@ -14570,6 +14570,1030 @@ function buildOdbTableCsv(tables, tableName) {
 	return new TextEncoder().encode(`${lines.join("\r\n")}\r\n`);
 }
 //#endregion
+//#region src/hsqldb/rowformat.ts
+var HsqldbRowFormatError = class extends Error {
+	constructor(message) {
+		super(`HSQLDB binary row format error: ${message}`);
+		this.name = "HsqldbRowFormatError";
+	}
+};
+const SQL_TYPE_NAME_TO_CODE = {
+	INTEGER: 4,
+	INT: 4,
+	IDENTITY: 4,
+	DOUBLE: 8,
+	FLOAT: 6,
+	REAL: 7,
+	VARCHAR: 12,
+	CHAR: 1,
+	CHARACTER: 1,
+	LONGVARCHAR: -1,
+	VARCHAR_IGNORECASE: 100,
+	DATE: 91,
+	TIME: 92,
+	TIMESTAMP: 93,
+	DATETIME: 93,
+	DECIMAL: 3,
+	NUMERIC: 2,
+	BIT: 16,
+	BOOLEAN: 16,
+	TINYINT: -6,
+	SMALLINT: 5,
+	BIGINT: -5
+};
+const UNSUPPORTED_SQL_TYPE_NAMES = /* @__PURE__ */ new Set([
+	"BINARY",
+	"VARBINARY",
+	"LONGVARBINARY",
+	"OTHER",
+	"OBJECT"
+]);
+const LEADING_WORD_RE = /^([A-Za-z_][A-Za-z0-9_]*)/;
+function resolveHsqldbTypeCode(declaredType) {
+	const word = LEADING_WORD_RE.exec(declaredType.trim())?.[1]?.toUpperCase();
+	if (word === void 0) throw new HsqldbRowFormatError(`cannot resolve a SQL type name from column type clause "${declaredType}"`);
+	if (UNSUPPORTED_SQL_TYPE_NAMES.has(word)) throw new HsqldbRowFormatError(`column type "${word}" has no document-content-model ContentCellValue equivalent (binary/object column types are not representable) -- from declared type "${declaredType}"`);
+	const code = SQL_TYPE_NAME_TO_CODE[word];
+	if (code === void 0) throw new HsqldbRowFormatError(`unrecognised HSQLDB column type "${word}" -- from declared type "${declaredType}"`);
+	return code;
+}
+var HsqldbDataCursor = class {
+	bytes;
+	view;
+	position;
+	constructor(bytes, offset = 0) {
+		this.bytes = bytes;
+		this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		this.position = offset;
+	}
+	readUint8() {
+		const value = this.view.getUint8(this.position);
+		this.position += 1;
+		return value;
+	}
+	readInt16() {
+		const value = this.view.getInt16(this.position, false);
+		this.position += 2;
+		return value;
+	}
+	readInt32() {
+		const value = this.view.getInt32(this.position, false);
+		this.position += 4;
+		return value;
+	}
+	readBigInt64() {
+		const value = this.view.getBigInt64(this.position, false);
+		this.position += 8;
+		return value;
+	}
+	readFloat64() {
+		const value = this.view.getFloat64(this.position, false);
+		this.position += 8;
+		return value;
+	}
+	readBytes(length) {
+		const slice = this.bytes.subarray(this.position, this.position + length);
+		this.position += length;
+		return slice;
+	}
+};
+function readModifiedUtf8(bytes) {
+	let result = "";
+	let i = 0;
+	while (i < bytes.length) {
+		const b0 = bytes[i];
+		if (b0 === void 0) throw new HsqldbRowFormatError("truncated modified-UTF-8 byte sequence");
+		if (b0 > 0 && b0 < 128) {
+			result += String.fromCharCode(b0);
+			i += 1;
+			continue;
+		}
+		const leadNibble = b0 >> 4;
+		if (leadNibble === 12 || leadNibble === 13) {
+			const b1 = bytes[i + 1];
+			if (b1 === void 0 || (b1 & 192) !== 128) throw new HsqldbRowFormatError("malformed modified-UTF-8 2-byte sequence");
+			result += String.fromCharCode((b0 & 31) << 6 | b1 & 63);
+			i += 2;
+			continue;
+		}
+		if (leadNibble === 14) {
+			const b1 = bytes[i + 1];
+			const b2 = bytes[i + 2];
+			if (b1 === void 0 || b2 === void 0 || (b1 & 192) !== 128 || (b2 & 192) !== 128) throw new HsqldbRowFormatError("malformed modified-UTF-8 3-byte sequence");
+			result += String.fromCharCode((b0 & 15) << 12 | (b1 & 63) << 6 | b2 & 63);
+			i += 3;
+			continue;
+		}
+		throw new HsqldbRowFormatError(`malformed modified-UTF-8 lead byte 0x${b0.toString(16)}`);
+	}
+	return result;
+}
+function signedBigIntFromBytes(bytes) {
+	if (bytes.length === 0) return 0n;
+	let magnitude = 0n;
+	for (const byte of bytes) magnitude = magnitude << 8n | BigInt(byte);
+	const firstByte = bytes[0];
+	return firstByte !== void 0 && (firstByte & 128) !== 0 ? magnitude - (1n << BigInt(8 * bytes.length)) : magnitude;
+}
+function decimalNumberFromUnscaled(unscaled, scale) {
+	const isNegative = unscaled < 0n;
+	const magnitudeDigits = (isNegative ? -unscaled : unscaled).toString();
+	const sign = isNegative ? "-" : "";
+	if (scale <= 0) return Number(`${sign}${magnitudeDigits}${"0".repeat(-scale)}`);
+	const padded = magnitudeDigits.padStart(scale + 1, "0");
+	const wholePart = padded.slice(0, padded.length - scale);
+	const fractionPart = padded.slice(padded.length - scale);
+	return Number(`${sign}${wholePart}.${fractionPart}`);
+}
+function pad2$1(n) {
+	return String(n).padStart(2, "0");
+}
+function epochMillisToLocalDate(epochMillis) {
+	return new Date(Number(epochMillis));
+}
+function formatLocalDate(epochMillis) {
+	const date = epochMillisToLocalDate(epochMillis);
+	return `${date.getFullYear()}-${pad2$1(date.getMonth() + 1)}-${pad2$1(date.getDate())}`;
+}
+function formatLocalTime(epochMillis) {
+	const date = epochMillisToLocalDate(epochMillis);
+	const base = `${pad2$1(date.getHours())}:${pad2$1(date.getMinutes())}:${pad2$1(date.getSeconds())}`;
+	return date.getMilliseconds() === 0 ? base : `${base}.${String(date.getMilliseconds()).padStart(3, "0")}`;
+}
+function formatLocalTimestamp(epochMillis, nanos) {
+	const date = epochMillisToLocalDate(epochMillis);
+	const base = `${date.getFullYear()}-${pad2$1(date.getMonth() + 1)}-${pad2$1(date.getDate())} ${pad2$1(date.getHours())}:${pad2$1(date.getMinutes())}:${pad2$1(date.getSeconds())}`;
+	return nanos === 0 ? base : `${base}.${String(nanos).padStart(9, "0")}`;
+}
+function readHsqldbColumnValue(cursor, typeCode) {
+	if (cursor.readUint8() === 0) return { kind: "empty" };
+	switch (typeCode) {
+		case 1:
+		case 12:
+		case -1:
+		case 100: {
+			const byteLength = cursor.readInt32();
+			return {
+				kind: "string",
+				value: readModifiedUtf8(cursor.readBytes(byteLength))
+			};
+		}
+		case 5:
+		case -6: return {
+			kind: "number",
+			value: cursor.readInt16()
+		};
+		case 4: return {
+			kind: "number",
+			value: cursor.readInt32()
+		};
+		case -5: return {
+			kind: "number",
+			value: Number(cursor.readBigInt64())
+		};
+		case 6:
+		case 7:
+		case 8: return {
+			kind: "number",
+			value: cursor.readFloat64()
+		};
+		case 2:
+		case 3: {
+			const byteLength = cursor.readInt32();
+			const magnitudeBytes = cursor.readBytes(byteLength);
+			const scale = cursor.readInt32();
+			return {
+				kind: "number",
+				value: decimalNumberFromUnscaled(signedBigIntFromBytes(magnitudeBytes), scale)
+			};
+		}
+		case 16: return {
+			kind: "boolean",
+			value: cursor.readUint8() !== 0
+		};
+		case 91: return {
+			kind: "date",
+			value: formatLocalDate(cursor.readBigInt64())
+		};
+		case 92: return {
+			kind: "time",
+			value: formatLocalTime(cursor.readBigInt64())
+		};
+		case 93: return {
+			kind: "date",
+			value: formatLocalTimestamp(cursor.readBigInt64(), cursor.readInt32())
+		};
+		default: throw new HsqldbRowFormatError(`unsupported SQL type code ${typeCode} while decoding a row value`);
+	}
+}
+//#endregion
+//#region src/hsqldb/cache.ts
+const SUPPORTED_COMPATIBLE_VERSION_PREFIXES = ["1.7.", "1.8."];
+function parseHsqldbProperties(text) {
+	const props = /* @__PURE__ */ new Map();
+	for (const rawLine of text.split("\n")) {
+		const line = rawLine.trim();
+		if (line.length === 0 || line.startsWith("#")) continue;
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+		props.set(line.slice(0, eq).trim(), line.slice(eq + 1).trim());
+	}
+	const compatibleVersion = props.get("hsqldb.compatible_version");
+	if (compatibleVersion !== void 0 && !SUPPORTED_COMPATIBLE_VERSION_PREFIXES.some((prefix) => compatibleVersion.startsWith(prefix))) throw new HsqldbRowFormatError(`database/properties declares hsqldb.compatible_version "${compatibleVersion}" -- this decoder is scoped to the HSQLDB 1.7.x/1.8.x CACHED-table row-store format (the version LibreOffice's own embedded driver ships) and does not know this version's own on-disk row-store layout`);
+	return {
+		cacheFileScale: Number(props.get("hsqldb.cache_file_scale") ?? "1") === 1 ? 1 : 8,
+		compatibleVersion
+	};
+}
+const SET_TABLE_INDEX_RE = /^SET\s+TABLE\s+("(?:[^"]|"")*"|[A-Za-z_][A-Za-z0-9_$#]*)\s+INDEX'((?:[^']|'')*)'\s*$/i;
+function unquoteIdentifier(raw) {
+	if (raw.length >= 2 && raw.startsWith("\"") && raw.endsWith("\"")) return raw.slice(1, -1).replace(/""/g, "\"");
+	return raw;
+}
+function parseHsqldbIndexRoots(scriptText) {
+	const roots = /* @__PURE__ */ new Map();
+	for (const rawLine of scriptText.split("\n")) {
+		const match = SET_TABLE_INDEX_RE.exec(rawLine.trim());
+		if (match === null) continue;
+		const rawName = match[1] ?? "";
+		const tokensText = match[2] ?? "";
+		const tableName = unquoteIdentifier(rawName).toUpperCase();
+		const tokens = tokensText.trim().length === 0 ? [] : tokensText.trim().split(/\s+/);
+		if (tokens.length !== 2) throw new HsqldbRowFormatError(`table "${tableName}" declares ${Math.max(tokens.length - 1, 0)} index root(s) in its SET TABLE...INDEX line -- only a single-index (primary-key-only) CACHED table is supported`);
+		const rootToken = tokens[0] ?? "";
+		const rootPos = Number(rootToken);
+		if (!Number.isInteger(rootPos)) throw new HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has a non-integer root position "${rootToken}"`);
+		roots.set(tableName, rootPos);
+	}
+	return roots;
+}
+function readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, columns) {
+	const typeCodes = columns.map((column) => resolveHsqldbTypeCode(column.type));
+	const results = [];
+	function visit(pos) {
+		if (pos <= 0) return;
+		const byteOffset = pos * cacheFileScale;
+		if (byteOffset < 0 || byteOffset + 4 > dataBytes.length) throw new HsqldbRowFormatError(`row position ${pos} (byte offset ${byteOffset}) falls outside database/data (${dataBytes.length} bytes)`);
+		const cursor = new HsqldbDataCursor(dataBytes, byteOffset);
+		const storageSize = cursor.readInt32();
+		const rowEnd = byteOffset + storageSize;
+		if (storageSize <= 0 || rowEnd > dataBytes.length) throw new HsqldbRowFormatError(`row at position ${pos} declares an invalid storage size ${storageSize}`);
+		cursor.readInt32();
+		const iLeft = cursor.readInt32();
+		const iRight = cursor.readInt32();
+		cursor.readInt32();
+		const values = columns.map((_column, index) => {
+			const typeCode = typeCodes[index];
+			if (typeCode === void 0) throw new HsqldbRowFormatError("internal error: column/type-code alignment failure");
+			return readHsqldbColumnValue(cursor, typeCode);
+		});
+		if (cursor.position > rowEnd) throw new HsqldbRowFormatError(`row at position ${pos} overran its own declared storage size (consumed ${cursor.position - byteOffset} bytes, declared ${storageSize})`);
+		visit(iLeft);
+		results.push(values);
+		visit(iRight);
+	}
+	visit(rootPos);
+	return results;
+}
+function decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText) {
+	const { cacheFileScale } = parseHsqldbProperties(propertiesText);
+	const roots = parseHsqldbIndexRoots(scriptText);
+	return tables.map((table) => {
+		const rootPos = roots.get(table.tableName.toUpperCase());
+		if (rootPos === void 0) return table;
+		const rows = readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, table.columns);
+		return {
+			...table,
+			rows
+		};
+	});
+}
+//#endregion
+//#region src/firebird/reader.ts
+var FirebirdBackupParseError = class extends Error {
+	offset;
+	constructor(message, offset) {
+		super(`Firebird backup parse error at byte offset ${offset}: ${message}`);
+		this.name = "FirebirdBackupParseError";
+		this.offset = offset;
+	}
+};
+var FirebirdBackupReader = class {
+	bytes;
+	position = 0;
+	constructor(bytes) {
+		this.bytes = bytes;
+	}
+	get offset() {
+		return this.position;
+	}
+	atEnd() {
+		return this.position >= this.bytes.length;
+	}
+	readTag() {
+		const byte = this.bytes[this.position];
+		if (byte === void 0) throw new FirebirdBackupParseError("unexpected end of stream reading a tag byte", this.position);
+		this.position++;
+		return byte;
+	}
+	peekTag() {
+		return this.bytes[this.position];
+	}
+	readLengthByte() {
+		const byte = this.bytes[this.position];
+		if (byte === void 0) throw new FirebirdBackupParseError("unexpected end of stream reading an attribute length byte", this.position);
+		this.position++;
+		return byte;
+	}
+	readRawBytes(length) {
+		if (this.position + length > this.bytes.length) throw new FirebirdBackupParseError(`unexpected end of stream reading ${length} raw byte(s)`, this.position);
+		const slice = this.bytes.subarray(this.position, this.position + length);
+		this.position += length;
+		return slice;
+	}
+	readAttributeBytes() {
+		const length = this.readLengthByte();
+		return this.readRawBytes(length);
+	}
+	readInt32Attribute() {
+		const bytes = this.readAttributeBytes();
+		if (bytes.length !== 4) throw new FirebirdBackupParseError(`expected a 4-byte int32 attribute, found ${bytes.length} byte(s)`, this.position);
+		return (bytes[0] ?? 0) | (bytes[1] ?? 0) << 8 | (bytes[2] ?? 0) << 16 | (bytes[3] ?? 0) << 24;
+	}
+	readTextAttribute() {
+		const bytes = this.readAttributeBytes();
+		return new TextDecoder("utf-8").decode(bytes);
+	}
+	skipAttributeValue() {
+		this.readAttributeBytes();
+	}
+	skipFlatRecordAttributes() {
+		for (;;) {
+			if (this.readTag() === 0) return;
+			this.skipAttributeValue();
+		}
+	}
+	readRawPayload(length) {
+		return this.readRawBytes(length);
+	}
+	readBlobSegmentLength() {
+		return this.readLengthByte() | this.readLengthByte() << 8;
+	}
+	readSignedByte() {
+		const byte = this.bytes[this.position];
+		if (byte === void 0) throw new FirebirdBackupParseError("unexpected end of stream reading a compression control byte", this.position);
+		this.position++;
+		return byte >= 128 ? byte - 256 : byte;
+	}
+	readCompressedPayload(decompressedLength) {
+		const output = new Uint8Array(decompressedLength);
+		let written = 0;
+		while (written < decompressedLength) {
+			const count = this.readSignedByte();
+			if (count > 0) {
+				const remaining = decompressedLength - written;
+				const take = Math.min(count, remaining);
+				const literal = this.readRawBytes(take);
+				output.set(literal, written);
+				written += take;
+			} else if (count < 0) {
+				const repeatCount = Math.min(-count, decompressedLength - written);
+				const fillByte = this.readLengthByte();
+				output.fill(fillByte, written, written + repeatCount);
+				written += repeatCount;
+			}
+		}
+		return output;
+	}
+};
+var XdrReader = class {
+	bytes;
+	position;
+	end;
+	constructor(bytes, start = 0, end = bytes.length) {
+		this.bytes = bytes;
+		this.position = start;
+		this.end = end;
+	}
+	get offset() {
+		return this.position;
+	}
+	atEnd() {
+		return this.position >= this.end;
+	}
+	readInt32() {
+		if (this.position + 4 > this.end) throw new FirebirdBackupParseError("unexpected end of XDR data reading a 4-byte integer", this.position);
+		const b0 = this.bytes[this.position] ?? 0;
+		const b1 = this.bytes[this.position + 1] ?? 0;
+		const b2 = this.bytes[this.position + 2] ?? 0;
+		const b3 = this.bytes[this.position + 3] ?? 0;
+		this.position += 4;
+		return b0 << 24 | b1 << 16 | b2 << 8 | b3 | 0;
+	}
+	readInt16() {
+		return this.readInt32() << 16 >> 16;
+	}
+	readInt64() {
+		const high = this.readInt32();
+		const low = this.readInt32();
+		return BigInt(high) << 32n | BigInt(low) & 4294967295n;
+	}
+	readDouble() {
+		if (this.position + 8 > this.end) throw new FirebirdBackupParseError("unexpected end of XDR data reading an 8-byte double", this.position);
+		const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+		for (let i = 0; i < 8; i++) view.setUint8(i, this.bytes[this.position + i] ?? 0);
+		this.position += 8;
+		return view.getFloat64(0, false);
+	}
+	readFloat() {
+		if (this.position + 4 > this.end) throw new FirebirdBackupParseError("unexpected end of XDR data reading a 4-byte float", this.position);
+		const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(4));
+		for (let i = 0; i < 4; i++) view.setUint8(i, this.bytes[this.position + i] ?? 0);
+		this.position += 4;
+		return view.getFloat32(0, false);
+	}
+	readOpaque(len) {
+		if (this.position + len > this.end) throw new FirebirdBackupParseError(`unexpected end of XDR data reading ${len} opaque byte(s)`, this.position);
+		const slice = this.bytes.subarray(this.position, this.position + len);
+		this.position += len;
+		const padding = (4 - len % 4) % 4;
+		this.position += padding;
+		return slice;
+	}
+};
+const BLR_TO_PHYSICAL_TYPE = /* @__PURE__ */ new Map([
+	[7, "short"],
+	[8, "long"],
+	[9, "quad"],
+	[10, "real"],
+	[11, "double"],
+	[12, "sql_date"],
+	[13, "sql_time"],
+	[14, "text"],
+	[15, "text"],
+	[16, "int64"],
+	[23, "boolean"],
+	[24, "dec64"],
+	[25, "dec128"],
+	[26, "int128"],
+	[27, "double"],
+	[28, "unsupported-tz"],
+	[29, "unsupported-tz"],
+	[30, "unsupported-tz"],
+	[31, "unsupported-tz"],
+	[35, "timestamp"],
+	[37, "varying"],
+	[38, "varying"],
+	[40, "cstring"],
+	[41, "cstring"],
+	[261, "blob"]
+]);
+var FirebirdUnsupportedFieldTypeError = class extends Error {
+	blrType;
+	constructor(blrType) {
+		super(`Firebird backup: field has BLR type ${blrType}, which is not a recognised column datatype opcode for a Firebird-embedded .odb's own user/system tables`);
+		this.name = "FirebirdUnsupportedFieldTypeError";
+		this.blrType = blrType;
+	}
+};
+function decodeBlrType(blrType) {
+	const physical = BLR_TO_PHYSICAL_TYPE.get(blrType);
+	if (physical === void 0) throw new FirebirdUnsupportedFieldTypeError(blrType);
+	return physical;
+}
+function describeFieldType(physical, lengthBytes, scale, characterLength) {
+	switch (physical) {
+		case "short": return scale === 0 ? "SMALLINT" : `NUMERIC(4,${-scale})`;
+		case "long": return scale === 0 ? "INTEGER" : `NUMERIC(9,${-scale})`;
+		case "int64": return scale === 0 ? "BIGINT" : `NUMERIC(18,${-scale})`;
+		case "real": return "FLOAT";
+		case "double": return "DOUBLE PRECISION";
+		case "sql_date": return "DATE";
+		case "sql_time": return "TIME";
+		case "timestamp": return "TIMESTAMP";
+		case "text": return `CHAR(${characterLength ?? lengthBytes})`;
+		case "varying": return `VARCHAR(${characterLength ?? lengthBytes})`;
+		case "cstring": return `CSTRING(${characterLength ?? lengthBytes})`;
+		case "boolean": return "BOOLEAN";
+		case "blob": return "BLOB";
+		case "quad": return "ARRAY";
+		case "int128": return `NUMERIC(38,${-scale})`;
+		case "dec64": return "DECFLOAT(16)";
+		case "dec128": return "DECFLOAT(34)";
+		case "unsupported-tz": return "TIMESTAMP/TIME WITH TIME ZONE";
+	}
+}
+//#endregion
+//#region src/firebird/schema.ts
+const REC_FIELD = 4;
+const REC_RELATION_END$1 = 9;
+var FirebirdSchemaParseError = class extends Error {
+	constructor(message) {
+		super(`Firebird backup schema parse error: ${message}`);
+		this.name = "FirebirdSchemaParseError";
+	}
+};
+const ATT_RELATION_NAME$1 = 1;
+const ATT_FIELD_NAME = 1;
+const ATT_FIELD_TYPE = 8;
+const ATT_FIELD_LENGTH = 10;
+const ATT_FIELD_SCALE = 11;
+const ATT_FIELD_COMPUTED_FLAG = 23;
+const ATT_FIELD_CHARACTER_LENGTH = 41;
+function readField(reader) {
+	let name;
+	let blrType;
+	let lengthBytes = 0;
+	let scale = 0;
+	let characterLength;
+	let computed = false;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		switch (attribute) {
+			case ATT_FIELD_NAME:
+				name = reader.readTextAttribute();
+				break;
+			case ATT_FIELD_TYPE:
+				blrType = reader.readInt32Attribute();
+				break;
+			case ATT_FIELD_LENGTH:
+				lengthBytes = reader.readInt32Attribute();
+				break;
+			case ATT_FIELD_SCALE:
+				scale = reader.readInt32Attribute();
+				break;
+			case ATT_FIELD_CHARACTER_LENGTH:
+				characterLength = reader.readInt32Attribute();
+				break;
+			case ATT_FIELD_COMPUTED_FLAG:
+				computed = reader.readInt32Attribute() !== 0;
+				break;
+			default: reader.skipAttributeValue();
+		}
+	}
+	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);
+	return {
+		name,
+		physicalType,
+		lengthBytes,
+		scale,
+		characterLength,
+		typeLabel,
+		computed
+	};
+}
+function readRelationSchema(reader, onUnhandledNested) {
+	let name;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		if (attribute === ATT_RELATION_NAME$1) name = reader.readTextAttribute();
+		else reader.skipAttributeValue();
+	}
+	if (name === void 0) throw new FirebirdSchemaParseError("a rec_relation record had no att_relation_name attribute");
+	const fields = [];
+	for (;;) {
+		const recordType = reader.readTag();
+		if (recordType === REC_RELATION_END$1) break;
+		if (recordType === REC_FIELD) {
+			fields.push(readField(reader));
+			continue;
+		}
+		onUnhandledNested(recordType);
+	}
+	return {
+		name,
+		fields
+	};
+}
+//#endregion
+//#region src/firebird/date.ts
+const ISC_TIME_SECONDS_PRECISION = 1e4;
+function decodeFirebirdDate(days) {
+	let nday = days + 2400001 - 1721119;
+	const century = Math.floor((4 * nday - 1) / 146097);
+	nday = 4 * nday - 1 - 146097 * century;
+	let day = Math.floor(nday / 4);
+	nday = Math.floor((4 * day + 3) / 1461);
+	day = 4 * day + 3 - 1461 * nday;
+	day = Math.floor((day + 4) / 4);
+	let month = Math.floor((5 * day - 3) / 153);
+	day = 5 * day - 3 - 153 * month;
+	day = Math.floor((day + 5) / 5);
+	let year = 100 * century + nday;
+	if (month < 10) month += 3;
+	else {
+		month -= 9;
+		year += 1;
+	}
+	return {
+		year,
+		month,
+		day
+	};
+}
+function decodeFirebirdTime(ticks) {
+	let remaining = ticks;
+	const hours = Math.floor(remaining / (3600 * ISC_TIME_SECONDS_PRECISION));
+	remaining %= 3600 * ISC_TIME_SECONDS_PRECISION;
+	const minutes = Math.floor(remaining / (60 * ISC_TIME_SECONDS_PRECISION));
+	remaining %= 60 * ISC_TIME_SECONDS_PRECISION;
+	return {
+		hours,
+		minutes,
+		seconds: Math.floor(remaining / ISC_TIME_SECONDS_PRECISION),
+		fractions: remaining % ISC_TIME_SECONDS_PRECISION
+	};
+}
+function pad2(value) {
+	return String(value).padStart(2, "0");
+}
+function pad4(value) {
+	return String(value).padStart(4, "0");
+}
+function formatFirebirdDate(days) {
+	const { year, month, day } = decodeFirebirdDate(days);
+	return `${pad4(year)}-${pad2(month)}-${pad2(day)}`;
+}
+function formatFirebirdTime(ticks) {
+	const { hours, minutes, seconds, fractions } = decodeFirebirdTime(ticks);
+	const millis = Math.round(fractions / 10);
+	return `${pad2(hours)}:${pad2(minutes)}:${pad2(seconds)}.${String(millis).padStart(3, "0")}`;
+}
+function formatFirebirdTimestamp(days, ticks) {
+	return `${formatFirebirdDate(days)} ${formatFirebirdTime(ticks)}`;
+}
+//#endregion
+//#region src/firebird/data.ts
+const REC_DATA = 6;
+const REC_BLOB = 7;
+const REC_RELATION_END = 9;
+const REC_GEN_ID = 18;
+const REC_INDEX = 5;
+const REC_TRIGGER = 13;
+const ATT_RELATION_NAME = 1;
+const ATT_DATA_LENGTH = 1;
+const ATT_DATA_DATA = 2;
+const ATT_XDR_LENGTH = 17;
+var FirebirdDataParseError = class extends Error {
+	constructor(message) {
+		super(`Firebird backup data parse error: ${message}`);
+		this.name = "FirebirdDataParseError";
+	}
+};
+var FirebirdCompositeRecordUnsupportedError = class extends Error {
+	recordType;
+	constructor(recordType, context) {
+		super(`Firebird backup: encountered record type ${recordType} while ${context}, which this reader's own bounded implementation does not know how to skip safely (its own attribute/sub-record shape has not been verified against a real fixture) -- refusing to guess rather than risk silently desynchronising the rest of the stream`);
+		this.name = "FirebirdCompositeRecordUnsupportedError";
+		this.recordType = recordType;
+	}
+};
+function skipBlobRecord(reader) {
+	let segmentCount;
+	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();
+	}
+}
+function decodeRowValues(fields, payload) {
+	const storedFields = fields.filter((field) => !field.computed);
+	const xdr = new XdrReader(payload);
+	const rawValues = [];
+	for (const field of storedFields) switch (field.physicalType) {
+		case "short":
+			rawValues.push({
+				kind: "number",
+				value: field.scale === 0 ? xdr.readInt16() : xdr.readInt16() * 10 ** field.scale
+			});
+			break;
+		case "long":
+			rawValues.push({
+				kind: "number",
+				value: field.scale === 0 ? xdr.readInt32() : xdr.readInt32() * 10 ** field.scale
+			});
+			break;
+		case "int64": {
+			const raw = xdr.readInt64();
+			const scaled = field.scale === 0 ? Number(raw) : Number(raw) * 10 ** field.scale;
+			rawValues.push({
+				kind: "number",
+				value: scaled
+			});
+			break;
+		}
+		case "real":
+			rawValues.push({
+				kind: "number",
+				value: xdr.readFloat()
+			});
+			break;
+		case "double":
+			rawValues.push({
+				kind: "number",
+				value: xdr.readDouble()
+			});
+			break;
+		case "sql_date": {
+			const days = xdr.readInt32();
+			rawValues.push({
+				kind: "date",
+				value: formatFirebirdDate(days)
+			});
+			break;
+		}
+		case "sql_time": {
+			const ticks = xdr.readInt32() >>> 0;
+			rawValues.push({
+				kind: "time",
+				value: formatFirebirdTime(ticks)
+			});
+			break;
+		}
+		case "timestamp": {
+			const days = xdr.readInt32();
+			const ticks = xdr.readInt32() >>> 0;
+			rawValues.push({
+				kind: "date",
+				value: formatFirebirdTimestamp(days, ticks)
+			});
+			break;
+		}
+		case "text": {
+			const bytes = xdr.readOpaque(field.lengthBytes);
+			rawValues.push({
+				kind: "string",
+				value: new TextDecoder("utf-8").decode(bytes).replace(/\s+$/, "")
+			});
+			break;
+		}
+		case "varying": {
+			const stringLength = xdr.readInt16();
+			const bytes = xdr.readOpaque(stringLength);
+			rawValues.push({
+				kind: "string",
+				value: new TextDecoder("utf-8").decode(bytes)
+			});
+			break;
+		}
+		case "cstring": {
+			const stringLength = xdr.readInt16();
+			const bytes = xdr.readOpaque(stringLength);
+			rawValues.push({
+				kind: "string",
+				value: new TextDecoder("utf-8").decode(bytes)
+			});
+			break;
+		}
+		case "boolean": {
+			const bytes = xdr.readOpaque(field.lengthBytes);
+			rawValues.push({
+				kind: "boolean",
+				value: (bytes[0] ?? 0) !== 0
+			});
+			break;
+		}
+		case "blob":
+			xdr.readInt32();
+			xdr.readInt32();
+			rawValues.push({ kind: "empty" });
+			break;
+		case "quad":
+			xdr.readInt32();
+			xdr.readInt32();
+			rawValues.push({ kind: "empty" });
+			break;
+		case "int128":
+		case "dec64":
+		case "dec128":
+		case "unsupported-tz": throw new FirebirdDataParseError(`column "${field.name}" has physical type "${field.physicalType}", which this reader's own bounded implementation does not decode (FB4+-only types not exercised by this reader's Firebird 3.0-era real fixture) -- see the README's .odb Tier 3 Fidelity note`);
+	}
+	for (let i = 0; i < storedFields.length; i++) if (xdr.readInt16() !== 0) rawValues[i] = { kind: "empty" };
+	return rawValues.map((value) => value ?? { kind: "empty" });
+}
+function readRowGroup(reader, relation, compressed) {
+	const rows = [];
+	let terminator;
+	for (;;) {
+		const lengthTag = reader.readTag();
+		if (lengthTag !== ATT_DATA_LENGTH) throw new FirebirdDataParseError(`relation "${relation.name}": expected att_data_length (tag ${ATT_DATA_LENGTH}), found tag ${lengthTag}`);
+		let xdrLength = reader.readInt32Attribute();
+		const maybeXdrTag = reader.readTag();
+		if (maybeXdrTag === ATT_XDR_LENGTH) xdrLength = reader.readInt32Attribute();
+		else if (maybeXdrTag !== ATT_DATA_DATA) throw new FirebirdDataParseError(`relation "${relation.name}": expected att_xdr_length or att_data_data, found tag ${maybeXdrTag}`);
+		if (maybeXdrTag !== ATT_DATA_DATA) {
+			const dataTag = reader.readTag();
+			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));
+		let next = reader.readTag();
+		while (next === REC_BLOB) {
+			skipBlobRecord(reader);
+			next = reader.readTag();
+		}
+		if (next !== REC_DATA) {
+			terminator = next;
+			break;
+		}
+	}
+	return {
+		rows,
+		terminator
+	};
+}
+function readRelationData(reader, schema, compressed) {
+	let name;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		if (attribute === ATT_RELATION_NAME) name = reader.readTextAttribute();
+		else reader.skipAttributeValue();
+	}
+	if (name === void 0) throw new FirebirdDataParseError("a rec_relation_data record had no att_relation_name attribute");
+	const relation = schema.get(name);
+	if (relation === void 0) throw new FirebirdDataParseError(`rec_relation_data references relation "${name}", which no earlier rec_relation declared`);
+	const rows = [];
+	let recordType = reader.readTag();
+	for (;;) {
+		if (recordType === REC_RELATION_END) break;
+		if (recordType === REC_DATA) {
+			const group = readRowGroup(reader, relation, compressed);
+			rows.push(...group.rows);
+			recordType = group.terminator;
+			continue;
+		}
+		if (recordType === REC_GEN_ID) {
+			reader.readAttributeBytes();
+			recordType = reader.readTag();
+			continue;
+		}
+		if (recordType === REC_INDEX || recordType === REC_TRIGGER) {
+			reader.skipFlatRecordAttributes();
+			recordType = reader.readTag();
+			continue;
+		}
+		throw new FirebirdCompositeRecordUnsupportedError(recordType, `reading relation data for "${name}"`);
+	}
+	return {
+		relationName: name,
+		rows
+	};
+}
+//#endregion
+//#region src/firebird/backup.ts
+const REC_DATABASE = 1;
+const REC_RELATION = 3;
+const REC_RELATION_DATA = 8;
+const REC_END = 10;
+const REC_PHYSICAL_DB = 14;
+const FLAT_SKIPPABLE_RECORD_TYPES = /* @__PURE__ */ new Set([
+	2,
+	24,
+	31,
+	32,
+	33,
+	34,
+	35,
+	19,
+	20,
+	26,
+	12,
+	25,
+	36,
+	37,
+	39,
+	21,
+	22,
+	40,
+	41,
+	42,
+	43
+]);
+var FirebirdBackupFormatError = class extends Error {
+	constructor(message) {
+		super(`Firebird backup: ${message}`);
+		this.name = "FirebirdBackupFormatError";
+	}
+};
+const ATT_BACKUP_FORMAT = 2;
+const ATT_BACKUP_COMPRESS = 4;
+const ATT_BACKUP_TRANSPORTABLE = 5;
+const ATT_PAGE_SIZE = 5;
+function readBurpHeader(reader) {
+	let backupFormatVersion;
+	let transportable = false;
+	let compressed = false;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		switch (attribute) {
+			case ATT_BACKUP_FORMAT:
+				backupFormatVersion = reader.readInt32Attribute();
+				break;
+			case ATT_BACKUP_TRANSPORTABLE:
+				transportable = reader.readInt32Attribute() !== 0;
+				break;
+			case ATT_BACKUP_COMPRESS:
+				compressed = reader.readInt32Attribute() !== 0;
+				break;
+			default: reader.skipAttributeValue();
+		}
+	}
+	if (backupFormatVersion === void 0) throw new FirebirdBackupFormatError("the leading rec_burp record had no att_backup_format attribute -- not a recognisable gbak backup stream");
+	return {
+		backupFormatVersion,
+		transportable,
+		compressed
+	};
+}
+function readDatabaseHeader(reader) {
+	let pageSizeBytes;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		if (attribute === ATT_PAGE_SIZE) pageSizeBytes = reader.readInt32Attribute();
+		else reader.skipAttributeValue();
+	}
+	return { pageSizeBytes };
+}
+const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+function relationToColumns(relation) {
+	return relation.fields.filter((field) => !field.computed).map((field) => ({
+		name: field.name,
+		type: field.typeLabel
+	}));
+}
+function readFirebirdBackup(bytes) {
+	const reader = new FirebirdBackupReader(bytes);
+	const leadingRecordType = reader.readTag();
+	if (leadingRecordType !== 0) throw new FirebirdBackupFormatError(`expected the stream to open with rec_burp (tag 0), found tag ${leadingRecordType} -- not a recognisable gbak backup stream`);
+	const { backupFormatVersion, transportable, compressed } = readBurpHeader(reader);
+	if (backupFormatVersion !== 10) throw new FirebirdBackupFormatError(`backup format version ${backupFormatVersion} is not supported -- this reader has only been built and verified against format version 10 (Firebird 3.0-era gbak output). Refusing to guess at a different format's own attribute/record shape rather than risk silently misdecoding it.`);
+	if (!transportable) throw new FirebirdBackupFormatError("backup is in non-transportable (native binary) row format (att_backup_transportable=false) -- this reader only decodes the transportable/XDR row encoding, the one every real fixture it was built against actually uses (gbak's own default).");
+	let pageSizeBytes;
+	const schema = /* @__PURE__ */ new Map();
+	const tablesInOrder = [];
+	const rowsByRelation = /* @__PURE__ */ new Map();
+	for (;;) {
+		const recordType = reader.readTag();
+		if (recordType === REC_END) break;
+		if (recordType === REC_DATABASE || recordType === REC_PHYSICAL_DB) {
+			pageSizeBytes = readDatabaseHeader(reader).pageSizeBytes ?? pageSizeBytes;
+			continue;
+		}
+		if (recordType === REC_RELATION) {
+			const relation = readRelationSchema(reader, (nestedRecordType) => {
+				throw new FirebirdCompositeRecordUnsupportedError(nestedRecordType, "reading a relation's own schema (a rec_view child, most likely)");
+			});
+			schema.set(relation.name, relation);
+			tablesInOrder.push(relation.name);
+			continue;
+		}
+		if (recordType === REC_RELATION_DATA) {
+			const result = readRelationData(reader, schema, compressed);
+			rowsByRelation.set(result.relationName, result.rows);
+			continue;
+		}
+		if (FLAT_SKIPPABLE_RECORD_TYPES.has(recordType)) {
+			reader.skipFlatRecordAttributes();
+			continue;
+		}
+		throw new FirebirdCompositeRecordUnsupportedError(recordType, "walking the backup stream's own top-level record sequence");
+	}
+	const tables = tablesInOrder.map((name) => {
+		const relation = schema.get(name);
+		if (relation === void 0) throw new FirebirdBackupFormatError(`internal error: relation "${name}" missing from its own schema map`);
+		const rows = rowsByRelation.get(name) ?? [];
+		return {
+			tableName: relation.name,
+			columns: relationToColumns(relation),
+			rows
+		};
+	});
+	return {
+		summary: {
+			backupFormatVersion,
+			transportable,
+			compressed,
+			pageSizeBytes
+		},
+		tables
+	};
+}
+//#endregion
 //#region src/odb/read.ts
 var OdbNoEmbeddedDataSourceError = class extends Error {
 	url;
@@ -14588,12 +15612,21 @@ var OdbUnsupportedFormatError = class extends Error {
 	}
 };
 const DATABASE_SCRIPT_PART = "database/script";
+const DATABASE_DATA_PART = "database/data";
+const DATABASE_PROPERTIES_PART = "database/properties";
+const DATABASE_FIREBIRD_PART = "database/firebird.fbk";
 function isXmlMediaType(mediaType) {
 	return mediaType === "text/xml" || mediaType === "application/xml" || mediaType.endsWith("+xml");
 }
-const GZIP_MAGIC = [31, 139];
+function isZlibHeader(bytes) {
+	if (bytes.length < 2) return false;
+	const cmf = bytes[0];
+	const flg = bytes[1];
+	if (cmf === void 0 || flg === void 0) return false;
+	return (cmf & 15) === 8 && (cmf * 256 + flg) % 31 === 0;
+}
 function classifyScriptBytes(bytes) {
-	if (bytes.length >= GZIP_MAGIC.length && bytes[0] === GZIP_MAGIC[0] && bytes[1] === GZIP_MAGIC[1]) return "compressed";
+	if (isZlibHeader(bytes)) return "compressed";
 	for (const byte of bytes) if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13) return "binary";
 	try {
 		new TextDecoder("utf-8", { fatal: true }).decode(bytes);
@@ -14608,18 +15641,32 @@ function readOdbTables(pkg) {
 	const url = inventory.connection.url;
 	if (url === void 0) throw new OdbUnsupportedFormatError("unrecognised-engine", "an embedded connection with no connection url to identify its engine");
 	const engine = url.slice(14);
-	if (engine === "firebird") throw new OdbUnsupportedFormatError("firebird", `Firebird's embedded database engine ("${url}")`);
+	if (engine === "firebird") {
+		const firebirdPart = pkg.parts[DATABASE_FIREBIRD_PART];
+		if (firebirdPart === void 0) throw new OdbUnsupportedFormatError("unrecognised-engine", `an embedded Firebird engine with no ${DATABASE_FIREBIRD_PART} part -- an unrecognised embedded storage shape`);
+		if (firebirdPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_FIREBIRD_PART} is not a binary part (found kind "${firebirdPart.kind}") -- malformed .odb package`);
+		return readFirebirdBackup(base64ToBytes$2(firebirdPart.base64)).tables;
+	}
 	if (engine !== "hsqldb") throw new OdbUnsupportedFormatError("unrecognised-engine", `the embedded "${engine}" database engine`);
 	const manifestEntry = readManifest(pkg).entries.find((entry) => entry.fullPath === DATABASE_SCRIPT_PART);
 	if (manifestEntry !== void 0 && isXmlMediaType(manifestEntry.mediaType)) throw new Error(`readOdbTables: ${DATABASE_SCRIPT_PART} is declared as an XML sub-document in the manifest (media type "${manifestEntry.mediaType}") -- not a recognised HSQLDB script part`);
 	const scriptPart = pkg.parts[DATABASE_SCRIPT_PART];
-	if (scriptPart === void 0) throw new OdbUnsupportedFormatError("unrecognised-engine", `an embedded HSQLDB engine with no ${DATABASE_SCRIPT_PART} part -- binary HSQLDB cache-only storage, or an unrecognised embedded storage shape`);
+	if (scriptPart === void 0) throw new OdbUnsupportedFormatError("unrecognised-engine", `an embedded HSQLDB engine with no ${DATABASE_SCRIPT_PART} part -- an unrecognised embedded storage shape`);
 	if (scriptPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_SCRIPT_PART} is not a binary part (found kind "${scriptPart.kind}") -- malformed .odb package`);
 	const scriptBytes = base64ToBytes$2(scriptPart.base64);
 	const classification = classifyScriptBytes(scriptBytes);
-	if (classification === "compressed") throw new OdbUnsupportedFormatError("hsqldb-compressed", "HSQLDB's compressed script format (hsqldb.script_format=3)");
-	if (classification === "binary") throw new OdbUnsupportedFormatError("hsqldb-binary", "HSQLDB's binary script format (hsqldb.script_format=1)");
-	return parseHsqldbScript(scriptBytes);
+	if (classification === "compressed") throw new OdbUnsupportedFormatError("hsqldb-compressed", "HSQLDB's compressed whole-script format (hsqldb.script_format=3) -- a zlib-wrapped copy of the same length-prefixed binary DDL/DML statement encoding hsqldb.script_format=1 uses, not compressed SQL text");
+	if (classification === "binary") throw new OdbUnsupportedFormatError("hsqldb-binary", "HSQLDB's binary whole-script format (hsqldb.script_format=1) -- a length-prefixed, COMMAND-tagged binary encoding of the script's own DDL/DML statements themselves, a materially different and larger undertaking than CACHED-table row-store decoding (Tier 2)");
+	return withCachedTableRows(pkg, parseHsqldbScript(scriptBytes), scriptBytes);
+}
+function withCachedTableRows(pkg, tables, scriptBytes) {
+	const dataPart = pkg.parts[DATABASE_DATA_PART];
+	if (dataPart === void 0) return tables;
+	if (dataPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is not a binary part (found kind "${dataPart.kind}") -- malformed .odb package`);
+	const propertiesPart = pkg.parts[DATABASE_PROPERTIES_PART];
+	if (propertiesPart === void 0) throw new Error(`readOdbTables: ${DATABASE_DATA_PART} is present but ${DATABASE_PROPERTIES_PART} is not -- malformed .odb package (a CACHED-table row store always ships alongside its own properties file, which this decoder needs for the cache file's own scale)`);
+	if (propertiesPart.kind !== "binary") throw new Error(`readOdbTables: ${DATABASE_PROPERTIES_PART} is not a binary part (found kind "${propertiesPart.kind}") -- malformed .odb package`);
+	return decodeHsqldbCachedTables(tables, new TextDecoder("utf-8", { fatal: true }).decode(scriptBytes), base64ToBytes$2(dataPart.base64), new TextDecoder("utf-8", { fatal: true }).decode(base64ToBytes$2(propertiesPart.base64)));
 }
 //#endregion
 //#region src/odb/spreadsheet.ts
@@ -14690,6 +15737,11 @@ function docxToPdf(bytes, options) {
 	const content = readDocxContent(openDocx(bytes).toPackage());
 	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
 	const { document: layout, formulas } = convertWordprocessingToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution,
@@ -14703,6 +15755,11 @@ function odtToPdf(bytes, options) {
 		measurer: createStandardFontMeasurer(),
 		formulas: content.formulas
 	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content: content.document,
+		layout
+	});
 	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution,
@@ -14713,6 +15770,11 @@ function pptxToPdf(bytes, options) {
 	const content = readPptxContent(openPptx(bytes).toPackage());
 	if (content.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
 	const { document: layout } = convertPresentationToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution
@@ -14725,6 +15787,11 @@ function odpToPdf(bytes, options) {
 		measurer: createStandardFontMeasurer(),
 		formulas: content.formulas
 	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content: content.document,
+		layout
+	});
 	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution,
@@ -14734,10 +15801,16 @@ function odpToPdf(bytes, options) {
 function odsToPdf(bytes, options) {
 	const content = readOdsContent(decodePackage$2(bytes));
 	if (content.kind !== "spreadsheet") throw new Error("readOdsContent returned a non-spreadsheet ContentDocument");
-	return writePdf(convertSpreadsheetToLayout(content, {
+	const layout = convertSpreadsheetToLayout(content, {
 		measurer: createStandardFontMeasurer(),
 		signal: options?.signal
-	}), {
+	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution
 	});
@@ -14745,7 +15818,13 @@ function odsToPdf(bytes, options) {
 function odgToPdf(bytes, options) {
 	const content = readOdgContent(decodePackage$2(bytes));
 	if (content.kind !== "drawing") throw new Error("readOdgContent returned a non-drawing ContentDocument");
-	return writePdf(convertDrawingToLayout(content, { measurer: createStandardFontMeasurer() }), {
+	const layout = convertDrawingToLayout(content, { measurer: createStandardFontMeasurer() });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
 		signal: options?.signal,
 		onSubstitution: options?.onSubstitution
 	});
@@ -14789,45 +15868,81 @@ function odfToPdf(bytes, options) {
 	});
 }
 function pdfToDocx(bytes, options) {
-	const content = reconstructWordprocessing(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructWordprocessing(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$1(buildDocxPackage(content));
 }
 function pdfToPptx(bytes, options) {
-	const content = reconstructPresentation(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructPresentation(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$1(buildPptxPackage(content));
 }
 function pdfToOdt(bytes, options) {
-	const content = reconstructWordprocessing(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructWordprocessing(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$2(buildOdtPackage(content));
 }
 function pdfToOdp(bytes, options) {
-	const content = reconstructPresentation(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructPresentation(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$2(buildOdpPackage(content));
 }
 function pdfToOdg(bytes, options) {
-	const content = reconstructDrawing(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructDrawing(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$2(buildOdgPackage(content));
 }
 function pdfToOds(bytes, options) {
-	const content = reconstructSpreadsheet(readPdf(bytes, {
+	const layout = readPdf(bytes, {
 		signal: options?.signal,
 		sink: options?.sink
-	}), { signal: options?.signal });
+	});
+	const content = reconstructSpreadsheet(layout, { signal: options?.signal });
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
 	return encodePackage$2(buildOdsPackage(content));
 }
 function odtToDocx(bytes, options) {
@@ -14835,6 +15950,10 @@ function odtToDocx(bytes, options) {
 	const content = readOdtContent(decodePackage$2(bytes)).document;
 	if (content.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$1(buildDocxPackage(content));
 }
 function docxToOdt(bytes, options) {
@@ -14842,6 +15961,10 @@ function docxToOdt(bytes, options) {
 	const content = readDocxContent(decodePackage$1(bytes));
 	if (content.kind !== "wordprocessing") throw new Error("readDocxContent returned a non-wordprocessing ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$2(buildOdtPackage(content));
 }
 function odpToPptx(bytes, options) {
@@ -14849,6 +15972,10 @@ function odpToPptx(bytes, options) {
 	const content = readOdpContent(decodePackage$2(bytes)).document;
 	if (content.kind !== "presentation") throw new Error("readOdpContent returned a non-presentation ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$1(buildPptxPackage(content));
 }
 function pptxToOdp(bytes, options) {
@@ -14856,6 +15983,10 @@ function pptxToOdp(bytes, options) {
 	const content = readPptxContent(decodePackage$1(bytes));
 	if (content.kind !== "presentation") throw new Error("readPptxContent returned a non-presentation ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$2(buildOdpPackage(content));
 }
 function odsToXlsx(bytes, options) {
@@ -14863,6 +15994,10 @@ function odsToXlsx(bytes, options) {
 	const content = readOdsContent(decodePackage$2(bytes));
 	if (content.kind !== "spreadsheet") throw new Error("readOdsContent returned a non-spreadsheet ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$1(buildXlsxPackage(content));
 }
 function xlsxToOds(bytes, options) {
@@ -14871,6 +16006,10 @@ function xlsxToOds(bytes, options) {
 	const content = readXlsxContent(pkg);
 	if (content.kind !== "spreadsheet") throw new Error("readXlsxContent returned a non-spreadsheet ContentDocument");
 	throwIfAborted(options?.signal);
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content
+	});
 	return encodePackage$2(buildOdsPackage(content));
 }
 var OdmUnresolvedSectionError = class extends Error {
@@ -15099,238 +16238,292 @@ function fromPdfDiagnostic(diagnostic) {
 }
 function createLocalDocumentConverter() {
 	return {
-		contractVersion: 1,
+		contractVersion: 2,
 		conversions: SUPPORTED_CONVERSIONS,
 		convert(request, options) {
 			const { source, targetFormat } = request;
 			const diagnostics = [];
+			let documentPackage;
+			const onDocument = (pkg) => {
+				documentPackage = pkg;
+			};
 			if (source.format === "docx" && targetFormat === "pdf") {
 				const bytes = docxToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pptx" && targetFormat === "pdf") {
 				const bytes = pptxToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odt" && targetFormat === "pdf") {
 				const bytes = odtToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odp" && targetFormat === "pdf") {
 				const bytes = odpToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "ods" && targetFormat === "pdf") {
 				const bytes = odsToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odg" && targetFormat === "pdf") {
 				const bytes = odgToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odf" && targetFormat === "pdf") {
 				const bytes = odfToPdf(source.bytes, {
 					signal: options.signal,
-					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c))
+					onSubstitution: (s, c) => diagnostics.push(substitutionDiagnostic(s, c)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pdf",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "docx") {
 				const bytes = pdfToDocx(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "docx",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "pptx") {
 				const bytes = pdfToPptx(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "pptx",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "odt") {
 				const bytes = pdfToOdt(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "odt",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "odp") {
 				const bytes = pdfToOdp(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "odp",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "ods") {
 				const bytes = pdfToOds(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "ods",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pdf" && targetFormat === "odg") {
 				const bytes = pdfToOdg(source.bytes, {
 					signal: options.signal,
-					sink: (d) => diagnostics.push(fromPdfDiagnostic(d))
+					sink: (d) => diagnostics.push(fromPdfDiagnostic(d)),
+					onDocument
 				});
 				return Promise.resolve({
 					document: {
 						format: "odg",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odt" && targetFormat === "docx") {
-				const bytes = odtToDocx(source.bytes, { signal: options.signal });
+				const bytes = odtToDocx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "docx",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "docx" && targetFormat === "odt") {
-				const bytes = docxToOdt(source.bytes, { signal: options.signal });
+				const bytes = docxToOdt(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "odt",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "odp" && targetFormat === "pptx") {
-				const bytes = odpToPptx(source.bytes, { signal: options.signal });
+				const bytes = odpToPptx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "pptx",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "pptx" && targetFormat === "odp") {
-				const bytes = pptxToOdp(source.bytes, { signal: options.signal });
+				const bytes = pptxToOdp(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "odp",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "ods" && targetFormat === "xlsx") {
-				const bytes = odsToXlsx(source.bytes, { signal: options.signal });
+				const bytes = odsToXlsx(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "xlsx",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			if (source.format === "xlsx" && targetFormat === "ods") {
-				const bytes = xlsxToOds(source.bytes, { signal: options.signal });
+				const bytes = xlsxToOds(source.bytes, {
+					signal: options.signal,
+					onDocument
+				});
 				return Promise.resolve({
 					document: {
 						format: "ods",
 						bytes
 					},
-					diagnostics
+					diagnostics,
+					package: documentPackage
 				});
 			}
 			return Promise.reject(/* @__PURE__ */ new Error(`unsupported conversion: ${source.format} -> ${targetFormat}`));
@@ -15344,4 +16537,4 @@ function fixedClock(date) {
 	return { now: () => date };
 }
 //#endregion
-export { AttributeSchema, BinaryPartSchema, COLOR_BLACK, CONTENT_FORMAT_VERSION, CommentSchema, CompactPackageSchema, CompactPartSchema, CompactXmlNodeSchema, ContentBlockSchema, ContentCellValueSchema, ContentDocumentSchema, ContentDrawPageSchema, ContentImageBlockSchema, ContentPageBreakSchema, ContentParagraphSchema, ContentPathPointSchema, ContentPathSegmentSchema, ContentRunSchema, ContentSectionSchema, ContentShapeSchema, ContentSheetCellSchema, ContentSheetColumnSchema, ContentSheetPrintRangeSchema, ContentSheetPrintSettingsSchema, ContentSheetRepeatRangeSchema, ContentSheetRowSchema, ContentSheetSchema, ContentSlideSchema, ContentStrokeSchema, ContentSubpathSchema, ContentTableCellSchema, ContentTableRowSchema, ContentTableSchema, ContentVectorSchema, DEFAULT_LAYOUT_FONT, DefinedNameSchema, DocxBytesSchema, DocxEditor, DocxParagraph, DocxRun, DocxTable, DocxTableCell, DocxTableRow, HsqldbScriptParseError, LAYOUT_FORMAT_VERSION, NOOP_DIAGNOSTIC_SINK, OdbNoEmbeddedDataSourceError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdgBoxVector, OdgBytesSchema, OdgEditor, OdgLineVector, OdgPage, OdgPathVector, OdmUnresolvedSectionError, OdpBytesSchema, OdpEditor, OdpShape, OdpSlide, OdsBytesSchema, OdsCell, OdsEditor, OdsSheet, OdtBytesSchema, OdtEditor, OdtList, OdtListItem, OdtParagraph, OdtRun, OdtTable, OdtTableCell, OdtTableRow, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PackageSchema, PartSchema, PdfBytesSchema, PdfEncryptedError, PdfParseError, PptxBytesSchema, PptxEditor, PptxShape, PptxSlide, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, XlsxBytesSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, applyMathVariant, attr, base64ToBytes, buildDocxPackage, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, buildXml, bytesToBase64, childrenWithTag, compactCodec, compactPackageCodec, convertDrawingToLayout, convertPresentationToLayout, convertSpreadsheetToLayout, convertWordprocessingToLayout, createDocx, createLocalDocumentConverter, createOdg, createOdp, createOds, createOdt, createPptx, decodeCompactPackage, decodeEntities, decodePackage, docxPdfCodec, docxToOdt, docxToPdf, elementChildren, elementLocalName, elementsWithTag, encodeCompactPackage, encodePackage, firstChildByLocalName, fixedClock, flipY, fromCompact, displayTextFor as hsqldbCellDisplayText, isCompactXmlNode, isContentBlock, isMathMlElement, isMathVariant, isXmlNode, layoutFormula, loadMathFont, localName, mapMathVariant, textContent as mathMlTextContent, odbTablesToSpreadsheetDocument, odbToCsv, odbToXlsx, odfToPdf, odgPdfCodec, odgToPdf, odmToPdf, odpPdfCodec, odpPptxCodec, odpToPdf, odpToPptx, odsPdfCodec, odsToPdf, odsToXlsx, odsXlsxCodec, odtDocxCodec, odtPdfCodec, odtToDocx, odtToPdf, openDocx, openOdg, openOdp, openOds, openOdt, openPptx, operatorProperties, packageCodec, parseHsqldbScript, parsePackage, parseXml, pdfCodec, pdfToDocx, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pptxPdfCodec, pptxToOdp, pptxToPdf, readDocxContent, readOdbTables, readOdfEmbeddedFormula, readOdfFormulaContent, readOdgContent, readOdpContent, readOdsContent, readOdtContent, readPdf, readPptxContent, reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing, resolveRelationships, rgbHexToColor, rootElement, serializePackage, systemClock, textContent$1 as textContent, throwIfAborted, toCompact, unzipPackage, walk, writePdf, xlsxToOds, xmlCodec, zipPackage };
+export { AttributeSchema, BinaryPartSchema, COLOR_BLACK, CONTENT_FORMAT_VERSION, CommentSchema, CompactPackageSchema, CompactPartSchema, CompactXmlNodeSchema, ContentBlockSchema, ContentCellValueSchema, ContentDocumentSchema, ContentDrawPageSchema, ContentImageBlockSchema, ContentPageBreakSchema, ContentParagraphSchema, ContentPathPointSchema, ContentPathSegmentSchema, ContentRunSchema, ContentSectionSchema, ContentShapeSchema, ContentSheetCellSchema, ContentSheetColumnSchema, ContentSheetPrintRangeSchema, ContentSheetPrintSettingsSchema, ContentSheetRepeatRangeSchema, ContentSheetRowSchema, ContentSheetSchema, ContentSlideSchema, ContentStrokeSchema, ContentSubpathSchema, ContentTableCellSchema, ContentTableRowSchema, ContentTableSchema, ContentVectorSchema, DEFAULT_LAYOUT_FONT, DefinedNameSchema, DocxBytesSchema, DocxEditor, DocxParagraph, DocxRun, DocxTable, DocxTableCell, DocxTableRow, SUPPORTED_BACKUP_FORMAT_VERSION as FIREBIRD_SUPPORTED_BACKUP_FORMAT_VERSION, FirebirdBackupFormatError, FirebirdBackupParseError, FirebirdCompositeRecordUnsupportedError, FirebirdDataParseError, FirebirdSchemaParseError, FirebirdUnsupportedFieldTypeError, HsqldbRowFormatError, HsqldbScriptParseError, LAYOUT_FORMAT_VERSION, NOOP_DIAGNOSTIC_SINK, OdbNoEmbeddedDataSourceError, OdbTableNotFoundError, OdbTableNotSpecifiedError, OdbUnsupportedFormatError, OdgBoxVector, OdgBytesSchema, OdgEditor, OdgLineVector, OdgPage, OdgPathVector, OdmUnresolvedSectionError, OdpBytesSchema, OdpEditor, OdpShape, OdpSlide, OdsBytesSchema, OdsCell, OdsEditor, OdsSheet, OdtBytesSchema, OdtEditor, OdtList, OdtListItem, OdtParagraph, OdtRun, OdtTable, OdtTableCell, OdtTableRow, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PackageSchema, PartSchema, PdfBytesSchema, PdfEncryptedError, PdfParseError, PptxBytesSchema, PptxEditor, PptxShape, PptxSlide, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN, XlsxBytesSchema, XmlCdataSchema, XmlCommentSchema, XmlDeclarationSchema, XmlElementSchema, XmlNodeSchema, XmlPartSchema, XmlPiSchema, XmlTextSchema, applyMathVariant, attr, base64ToBytes, buildDocxPackage, buildOdgPackage, buildOdpPackage, buildOdsPackage, buildOdtPackage, buildPptxPackage, buildXml, bytesToBase64, childrenWithTag, compactCodec, compactPackageCodec, convertDrawingToLayout, convertPresentationToLayout, convertSpreadsheetToLayout, convertWordprocessingToLayout, createDocx, createLocalDocumentConverter, createOdg, createOdp, createOds, createOdt, createPptx, decodeCompactPackage, decodeEntities, decodeHsqldbCachedTables, decodePackage, docxPdfCodec, docxToOdt, docxToPdf, elementChildren, elementLocalName, elementsWithTag, encodeCompactPackage, encodePackage, firstChildByLocalName, fixedClock, flipY, fromCompact, displayTextFor as hsqldbCellDisplayText, isCompactXmlNode, isContentBlock, isMathMlElement, isMathVariant, isXmlNode, layoutFormula, loadMathFont, localName, mapMathVariant, textContent as mathMlTextContent, odbTablesToSpreadsheetDocument, odbToCsv, odbToXlsx, odfToPdf, odgPdfCodec, odgToPdf, odmToPdf, odpPdfCodec, odpPptxCodec, odpToPdf, odpToPptx, odsPdfCodec, odsToPdf, odsToXlsx, odsXlsxCodec, odtDocxCodec, odtPdfCodec, odtToDocx, odtToPdf, openDocx, openOdg, openOdp, openOds, openOdt, openPptx, operatorProperties, packageCodec, parseHsqldbScript, parsePackage, parseXml, pdfCodec, pdfToDocx, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pptxPdfCodec, pptxToOdp, pptxToPdf, readDocxContent, readFirebirdBackup, readOdbTables, readOdfEmbeddedFormula, readOdfFormulaContent, readOdgContent, readOdpContent, readOdsContent, readOdtContent, readPdf, readPptxContent, reconstructDrawing, reconstructPresentation, reconstructSpreadsheet, reconstructWordprocessing, resolveRelationships, rgbHexToColor, rootElement, serializePackage, systemClock, textContent$1 as textContent, throwIfAborted, toCompact, unzipPackage, walk, writePdf, xlsxToOds, xmlCodec, zipPackage };