documents.js 1.52.0 → 1.53.1

package/dist/index.cjs

@@ -9211,12 +9211,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();
@@ -14571,6 +14571,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;
@@ -14589,12 +15613,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);
@@ -14609,18 +15642,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((0, odf_js.base64ToBytes)(firebirdPart.base64)).tables;
+	}
 	if (engine !== "hsqldb") throw new OdbUnsupportedFormatError("unrecognised-engine", `the embedded "${engine}" database engine`);
 	const manifestEntry = (0, odf_js.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 = (0, odf_js.base64ToBytes)(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), (0, odf_js.base64ToBytes)(dataPart.base64), new TextDecoder("utf-8", { fatal: true }).decode((0, odf_js.base64ToBytes)(propertiesPart.base64)));
 }
 //#endregion
 //#region src/odb/spreadsheet.ts
@@ -15704,6 +16751,14 @@ exports.DocxRun = DocxRun;
 exports.DocxTable = DocxTable;
 exports.DocxTableCell = DocxTableCell;
 exports.DocxTableRow = DocxTableRow;
+exports.FIREBIRD_SUPPORTED_BACKUP_FORMAT_VERSION = SUPPORTED_BACKUP_FORMAT_VERSION;
+exports.FirebirdBackupFormatError = FirebirdBackupFormatError;
+exports.FirebirdBackupParseError = FirebirdBackupParseError;
+exports.FirebirdCompositeRecordUnsupportedError = FirebirdCompositeRecordUnsupportedError;
+exports.FirebirdDataParseError = FirebirdDataParseError;
+exports.FirebirdSchemaParseError = FirebirdSchemaParseError;
+exports.FirebirdUnsupportedFieldTypeError = FirebirdUnsupportedFieldTypeError;
+exports.HsqldbRowFormatError = HsqldbRowFormatError;
 exports.HsqldbScriptParseError = HsqldbScriptParseError;
 Object.defineProperty(exports, "LAYOUT_FORMAT_VERSION", {
 	enumerable: true,
@@ -15904,6 +16959,7 @@ Object.defineProperty(exports, "decodeEntities", {
 		return ooxml_js.decodeEntities;
 	}
 });
+exports.decodeHsqldbCachedTables = decodeHsqldbCachedTables;
 Object.defineProperty(exports, "decodePackage", {
 	enumerable: true,
 	get: function() {
@@ -16024,6 +17080,7 @@ exports.pptxPdfCodec = pptxPdfCodec;
 exports.pptxToOdp = pptxToOdp;
 exports.pptxToPdf = pptxToPdf;
 exports.readDocxContent = readDocxContent;
+exports.readFirebirdBackup = readFirebirdBackup;
 exports.readOdbTables = readOdbTables;
 exports.readOdfEmbeddedFormula = readOdfEmbeddedFormula;
 exports.readOdfFormulaContent = readOdfFormulaContent;