documents.js 1.61.0 → 1.63.0

package/dist/fonts/ooxml.d.cts

@@ -0,0 +1,9 @@
+import { Package } from "ooxml.js";
+import { ProvidedFont } from "pdf-codec";
+//#region src/fonts/ooxml.d.ts
+declare class OoxmlEmbeddedFontError extends Error {
+  constructor(detail: string);
+}
+declare function extractOoxmlEmbeddedFonts(pkg: Package, kind: 'docx' | 'pptx'): ProvidedFont[];
+//#endregion
+export { OoxmlEmbeddedFontError, extractOoxmlEmbeddedFonts };

package/dist/fonts/ooxml.d.ts

@@ -0,0 +1,9 @@
+import { Package } from "ooxml.js";
+import { ProvidedFont } from "pdf-codec";
+//#region src/fonts/ooxml.d.ts
+declare class OoxmlEmbeddedFontError extends Error {
+  constructor(detail: string);
+}
+declare function extractOoxmlEmbeddedFonts(pkg: Package, kind: 'docx' | 'pptx'): ProvidedFont[];
+//#endregion
+export { OoxmlEmbeddedFontError, extractOoxmlEmbeddedFonts };

package/dist/fonts/ooxml.js

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

package/dist/fonts/registry.cjs

@@ -0,0 +1,18 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_fonts_odf = require("./odf.cjs");
+const require_fonts_ooxml = require("./ooxml.cjs");
+let pdf_codec = require("pdf-codec");
+//#region src/fonts/registry.ts
+function extractSourceFonts(source) {
+	return source.kind === "odf" ? require_fonts_odf.extractOdfEmbeddedFonts(source.package) : require_fonts_ooxml.extractOoxmlEmbeddedFonts(source.package, source.kind);
+}
+function createDocumentFontRegistry(source, options) {
+	return (0, pdf_codec.createFontRegistry)({
+		sourceFonts: extractSourceFonts(source),
+		fonts: options?.fonts,
+		onSubstitution: options?.onFontSubstitution
+	});
+}
+//#endregion
+exports.createDocumentFontRegistry = createDocumentFontRegistry;
+exports.extractSourceFonts = extractSourceFonts;

package/dist/fonts/registry.d.cts

@@ -0,0 +1,2 @@
+import { i as extractSourceFonts, n as FontSourcePackage, r as createDocumentFontRegistry, t as DocumentFontRegistryOptions } from "../registry-CtPhMD0f.cjs";
+export { DocumentFontRegistryOptions, FontSourcePackage, createDocumentFontRegistry, extractSourceFonts };

package/dist/fonts/registry.d.ts

@@ -0,0 +1,2 @@
+import { i as extractSourceFonts, n as FontSourcePackage, r as createDocumentFontRegistry, t as DocumentFontRegistryOptions } from "../registry-CrSqLIcn.js";
+export { DocumentFontRegistryOptions, FontSourcePackage, createDocumentFontRegistry, extractSourceFonts };

package/dist/fonts/registry.js

@@ -0,0 +1,16 @@
+import { extractOdfEmbeddedFonts } from "./odf.js";
+import { extractOoxmlEmbeddedFonts } from "./ooxml.js";
+import { createFontRegistry } from "pdf-codec";
+//#region src/fonts/registry.ts
+function extractSourceFonts(source) {
+	return source.kind === "odf" ? extractOdfEmbeddedFonts(source.package) : extractOoxmlEmbeddedFonts(source.package, source.kind);
+}
+function createDocumentFontRegistry(source, options) {
+	return createFontRegistry({
+		sourceFonts: extractSourceFonts(source),
+		fonts: options?.fonts,
+		onSubstitution: options?.onFontSubstitution
+	});
+}
+//#endregion
+export { createDocumentFontRegistry, extractSourceFonts };

package/dist/{geometry-DvwdrIij.d.cts → geometry-DaJr8yQW.d.cts}

@@ -1,5 +1,5 @@
-import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
+import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize as PageSize$1, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
 //#region src/model/geometry.d.ts
 declare function flipY(box: Box, containerHeightPt: number): Box;
 //#endregion
-export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };
+export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize$1 as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };

package/dist/{geometry-DvwdrIij.d.ts → geometry-DaJr8yQW.d.ts}

@@ -1,5 +1,5 @@
-import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
+import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize as PageSize$1, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
 //#region src/model/geometry.d.ts
 declare function flipY(box: Box, containerHeightPt: number): Box;
 //#endregion
-export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };
+export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize$1 as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };

package/dist/hsqldb/binary-script.cjs

@@ -0,0 +1,154 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hsqldb_script = require("./script.cjs");
+const require_hsqldb_rowformat = require("./rowformat.cjs");
+let fflate = require("fflate");
+//#region src/hsqldb/binary-script.ts
+var HsqldbBinaryScriptParseError = class extends Error {
+	offset;
+	constructor(message, offset) {
+		super(`HSQLDB binary script parse error at byte offset ${offset}: ${message}`);
+		this.name = "HsqldbBinaryScriptParseError";
+		this.offset = offset;
+	}
+};
+const RESULT_MODE_DATA = 3;
+const SQL_TYPE_VARCHAR = 12;
+const TABLE_INIT_WITH_SCHEMA = 1;
+const TABLE_INIT_WITHOUT_SCHEMA = 0;
+var BinaryScriptCursor = class {
+	cursor;
+	length;
+	constructor(bytes) {
+		this.cursor = new require_hsqldb_rowformat.HsqldbDataCursor(bytes);
+		this.length = bytes.length;
+	}
+	get position() {
+		return this.cursor.position;
+	}
+	set position(value) {
+		this.cursor.position = value;
+	}
+	hasRecordLength() {
+		return this.cursor.position + 4 <= this.length;
+	}
+	require(byteCount, what) {
+		if (this.cursor.position + byteCount > this.length) throw new HsqldbBinaryScriptParseError(`stream ends after ${this.length} bytes while reading ${what} (${byteCount} byte(s) needed)`, this.cursor.position);
+	}
+	readInt32(what) {
+		this.require(4, what);
+		return this.cursor.readInt32();
+	}
+	readInt16(what) {
+		this.require(2, what);
+		return this.cursor.readInt16();
+	}
+	readString(what) {
+		const byteLength = this.readInt32(`${what}'s own length prefix`);
+		if (byteLength < 0) throw new HsqldbBinaryScriptParseError(`${what} declares a negative length ${byteLength}`, this.cursor.position);
+		this.require(byteLength, what);
+		return require_hsqldb_rowformat.readModifiedUtf8(this.cursor.readBytes(byteLength));
+	}
+};
+function readResultMetaData(reader) {
+	const columnCount = reader.readInt32("the DDL result's own column count");
+	if (columnCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative column count ${columnCount}`, reader.position);
+	const columnTypes = [];
+	for (let i = 0; i < columnCount; i++) {
+		columnTypes.push(reader.readInt16(`column ${i}'s own SQL type`));
+		reader.readInt32(`column ${i}'s own declared size`);
+		reader.readInt32(`column ${i}'s own declared scale`);
+		reader.readString(`column ${i}'s own label`);
+		const tableName = reader.readString(`column ${i}'s own table name`);
+		const columnName = reader.readString(`column ${i}'s own name`);
+		reader.readString(`column ${i}'s own class name`);
+		if (tableName.length > 0 && columnName.length > 0) {
+			reader.readInt32(`column ${i}'s own table-column attribute mask`);
+			reader.readString(`column ${i}'s own catalog name`);
+			reader.readString(`column ${i}'s own schema name`);
+		}
+	}
+	return columnTypes;
+}
+function readDdlStatements(reader) {
+	const recordStart = reader.position;
+	const recordLength = reader.readInt32("the leading DDL result record's own length");
+	if (recordLength <= 4) throw new HsqldbBinaryScriptParseError(`the leading DDL result record declares an implausible length ${recordLength} -- not a recognisable HSQLDB binary script`, recordStart);
+	const mode = reader.readInt32("the DDL result's own mode");
+	if (mode !== RESULT_MODE_DATA) throw new HsqldbBinaryScriptParseError(`the leading record has Result mode ${mode}, not the DATA mode (${RESULT_MODE_DATA}) a script's own DDL result always carries -- not a recognisable HSQLDB binary script`, recordStart);
+	reader.readInt32("the DDL result's own database id");
+	reader.readInt32("the DDL result's own session id");
+	const columnTypes = readResultMetaData(reader);
+	const firstColumnType = columnTypes[0];
+	if (columnTypes.length !== 1 || firstColumnType !== SQL_TYPE_VARCHAR) throw new HsqldbBinaryScriptParseError(`the DDL result has ${columnTypes.length} column(s) of type [${columnTypes.join(", ")}] -- a script's own DDL result is always the single VARCHAR "COMMAND" column DatabaseScript.getScript builds`, recordStart);
+	const rowCount = reader.readInt32("the DDL result's own row count");
+	if (rowCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative row count ${rowCount}`, reader.position);
+	const statements = [];
+	for (let i = 0; i < rowCount; i++) {
+		reader.require(1, `DDL statement ${i}`);
+		const value = require_hsqldb_rowformat.readHsqldbColumnValue(reader.cursor, SQL_TYPE_VARCHAR);
+		if (value.kind !== "string") throw new HsqldbBinaryScriptParseError(`DDL statement ${i} decoded as a ${value.kind} value rather than a string`, reader.position);
+		statements.push(value.value);
+	}
+	const recordEnd = recordStart + recordLength;
+	if (reader.position > recordEnd) throw new HsqldbBinaryScriptParseError(`the DDL result overran its own declared length (consumed ${reader.position - recordStart} bytes, declared ${recordLength})`, reader.position);
+	reader.position = recordEnd;
+	return statements;
+}
+function readTableSection(reader, tables, options) {
+	if (!reader.hasRecordLength()) return;
+	if (reader.readInt32("a table section's own init record length") === 0) return;
+	const tableName = reader.readString("a table section's own table name");
+	const schemaFlag = reader.readInt32(`table "${tableName}"'s own schema-presence flag`);
+	if (schemaFlag !== TABLE_INIT_WITH_SCHEMA && schemaFlag !== TABLE_INIT_WITHOUT_SCHEMA) throw new HsqldbBinaryScriptParseError(`table "${tableName}"'s init record has schema flag ${schemaFlag}, which is neither ${TABLE_INIT_WITHOUT_SCHEMA} nor ${TABLE_INIT_WITH_SCHEMA}`, reader.position);
+	if (schemaFlag === TABLE_INIT_WITH_SCHEMA) reader.readString(`table "${tableName}"'s own schema name`);
+	const table = tables.get(tableName.toUpperCase());
+	if (table === void 0) throw new HsqldbBinaryScriptParseError(`the data section declares rows for table "${tableName}", which the script's own DDL never declared`, reader.position);
+	const typeCodes = table.columns.map((column) => require_hsqldb_rowformat.resolveHsqldbTypeCode(column.type));
+	const rows = [];
+	for (;;) {
+		const rowStart = reader.position;
+		const rowLength = reader.readInt32(`a row length in table "${tableName}"`);
+		if (rowLength === 0) break;
+		if (rowLength < 0) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" declares a negative length ${rowLength}`, rowStart);
+		const rowEnd = rowStart + rowLength;
+		reader.require(rowLength - 4, `a row in table "${tableName}"`);
+		rows.push(typeCodes.map((typeCode) => require_hsqldb_rowformat.readHsqldbColumnValue(reader.cursor, typeCode, options)));
+		if (reader.position > rowEnd) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" overran its own declared length (consumed ${reader.position - rowStart} bytes, declared ${rowLength})`, reader.position);
+		reader.position = rowEnd;
+	}
+	const declaredRowCount = reader.readInt32(`table "${tableName}"'s own trailing row count`);
+	if (declaredRowCount !== rows.length) throw new HsqldbBinaryScriptParseError(`table "${tableName}" declares ${declaredRowCount} row(s) in its own terminator but the section carried ${rows.length}`, reader.position);
+	return {
+		tableName,
+		rows
+	};
+}
+function parseHsqldbBinaryScript(bytes, options) {
+	const reader = new BinaryScriptCursor(bytes);
+	const scriptText = readDdlStatements(reader).join("\n");
+	const tables = require_hsqldb_script.parseHsqldbScript(new TextEncoder().encode(scriptText));
+	const tablesByName = new Map(tables.map((table) => [table.tableName.toUpperCase(), table]));
+	const rowsByTable = /* @__PURE__ */ new Map();
+	for (;;) {
+		const section = readTableSection(reader, tablesByName, options);
+		if (section === void 0) break;
+		rowsByTable.set(section.tableName.toUpperCase(), section.rows);
+	}
+	return {
+		scriptText,
+		tables: tables.map((table) => {
+			const rows = rowsByTable.get(table.tableName.toUpperCase());
+			return rows === void 0 ? table : {
+				...table,
+				rows
+			};
+		})
+	};
+}
+function inflateHsqldbCompressedScript(bytes) {
+	return (0, fflate.unzlibSync)(bytes);
+}
+//#endregion
+exports.HsqldbBinaryScriptParseError = HsqldbBinaryScriptParseError;
+exports.inflateHsqldbCompressedScript = inflateHsqldbCompressedScript;
+exports.parseHsqldbBinaryScript = parseHsqldbBinaryScript;

package/dist/hsqldb/binary-script.d.cts

@@ -0,0 +1,15 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
+import { HsqldbTable } from "./script.cjs";
+//#region src/hsqldb/binary-script.d.ts
+declare class HsqldbBinaryScriptParseError extends Error {
+  readonly offset: number;
+  constructor(message: string, offset: number);
+}
+interface HsqldbBinaryScript {
+  readonly scriptText: string;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function parseHsqldbBinaryScript(bytes: Uint8Array<ArrayBuffer>, options?: HsqldbDecodeOptions): HsqldbBinaryScript;
+declare function inflateHsqldbCompressedScript(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { HsqldbBinaryScript, HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/binary-script.d.ts

@@ -0,0 +1,15 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
+import { HsqldbTable } from "./script.js";
+//#region src/hsqldb/binary-script.d.ts
+declare class HsqldbBinaryScriptParseError extends Error {
+  readonly offset: number;
+  constructor(message: string, offset: number);
+}
+interface HsqldbBinaryScript {
+  readonly scriptText: string;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function parseHsqldbBinaryScript(bytes: Uint8Array<ArrayBuffer>, options?: HsqldbDecodeOptions): HsqldbBinaryScript;
+declare function inflateHsqldbCompressedScript(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { HsqldbBinaryScript, HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/binary-script.js

@@ -0,0 +1,151 @@
+import { parseHsqldbScript } from "./script.js";
+import { HsqldbDataCursor, readHsqldbColumnValue, readModifiedUtf8, resolveHsqldbTypeCode } from "./rowformat.js";
+import { unzlibSync } from "fflate";
+//#region src/hsqldb/binary-script.ts
+var HsqldbBinaryScriptParseError = class extends Error {
+	offset;
+	constructor(message, offset) {
+		super(`HSQLDB binary script parse error at byte offset ${offset}: ${message}`);
+		this.name = "HsqldbBinaryScriptParseError";
+		this.offset = offset;
+	}
+};
+const RESULT_MODE_DATA = 3;
+const SQL_TYPE_VARCHAR = 12;
+const TABLE_INIT_WITH_SCHEMA = 1;
+const TABLE_INIT_WITHOUT_SCHEMA = 0;
+var BinaryScriptCursor = class {
+	cursor;
+	length;
+	constructor(bytes) {
+		this.cursor = new HsqldbDataCursor(bytes);
+		this.length = bytes.length;
+	}
+	get position() {
+		return this.cursor.position;
+	}
+	set position(value) {
+		this.cursor.position = value;
+	}
+	hasRecordLength() {
+		return this.cursor.position + 4 <= this.length;
+	}
+	require(byteCount, what) {
+		if (this.cursor.position + byteCount > this.length) throw new HsqldbBinaryScriptParseError(`stream ends after ${this.length} bytes while reading ${what} (${byteCount} byte(s) needed)`, this.cursor.position);
+	}
+	readInt32(what) {
+		this.require(4, what);
+		return this.cursor.readInt32();
+	}
+	readInt16(what) {
+		this.require(2, what);
+		return this.cursor.readInt16();
+	}
+	readString(what) {
+		const byteLength = this.readInt32(`${what}'s own length prefix`);
+		if (byteLength < 0) throw new HsqldbBinaryScriptParseError(`${what} declares a negative length ${byteLength}`, this.cursor.position);
+		this.require(byteLength, what);
+		return readModifiedUtf8(this.cursor.readBytes(byteLength));
+	}
+};
+function readResultMetaData(reader) {
+	const columnCount = reader.readInt32("the DDL result's own column count");
+	if (columnCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative column count ${columnCount}`, reader.position);
+	const columnTypes = [];
+	for (let i = 0; i < columnCount; i++) {
+		columnTypes.push(reader.readInt16(`column ${i}'s own SQL type`));
+		reader.readInt32(`column ${i}'s own declared size`);
+		reader.readInt32(`column ${i}'s own declared scale`);
+		reader.readString(`column ${i}'s own label`);
+		const tableName = reader.readString(`column ${i}'s own table name`);
+		const columnName = reader.readString(`column ${i}'s own name`);
+		reader.readString(`column ${i}'s own class name`);
+		if (tableName.length > 0 && columnName.length > 0) {
+			reader.readInt32(`column ${i}'s own table-column attribute mask`);
+			reader.readString(`column ${i}'s own catalog name`);
+			reader.readString(`column ${i}'s own schema name`);
+		}
+	}
+	return columnTypes;
+}
+function readDdlStatements(reader) {
+	const recordStart = reader.position;
+	const recordLength = reader.readInt32("the leading DDL result record's own length");
+	if (recordLength <= 4) throw new HsqldbBinaryScriptParseError(`the leading DDL result record declares an implausible length ${recordLength} -- not a recognisable HSQLDB binary script`, recordStart);
+	const mode = reader.readInt32("the DDL result's own mode");
+	if (mode !== RESULT_MODE_DATA) throw new HsqldbBinaryScriptParseError(`the leading record has Result mode ${mode}, not the DATA mode (${RESULT_MODE_DATA}) a script's own DDL result always carries -- not a recognisable HSQLDB binary script`, recordStart);
+	reader.readInt32("the DDL result's own database id");
+	reader.readInt32("the DDL result's own session id");
+	const columnTypes = readResultMetaData(reader);
+	const firstColumnType = columnTypes[0];
+	if (columnTypes.length !== 1 || firstColumnType !== SQL_TYPE_VARCHAR) throw new HsqldbBinaryScriptParseError(`the DDL result has ${columnTypes.length} column(s) of type [${columnTypes.join(", ")}] -- a script's own DDL result is always the single VARCHAR "COMMAND" column DatabaseScript.getScript builds`, recordStart);
+	const rowCount = reader.readInt32("the DDL result's own row count");
+	if (rowCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative row count ${rowCount}`, reader.position);
+	const statements = [];
+	for (let i = 0; i < rowCount; i++) {
+		reader.require(1, `DDL statement ${i}`);
+		const value = readHsqldbColumnValue(reader.cursor, SQL_TYPE_VARCHAR);
+		if (value.kind !== "string") throw new HsqldbBinaryScriptParseError(`DDL statement ${i} decoded as a ${value.kind} value rather than a string`, reader.position);
+		statements.push(value.value);
+	}
+	const recordEnd = recordStart + recordLength;
+	if (reader.position > recordEnd) throw new HsqldbBinaryScriptParseError(`the DDL result overran its own declared length (consumed ${reader.position - recordStart} bytes, declared ${recordLength})`, reader.position);
+	reader.position = recordEnd;
+	return statements;
+}
+function readTableSection(reader, tables, options) {
+	if (!reader.hasRecordLength()) return;
+	if (reader.readInt32("a table section's own init record length") === 0) return;
+	const tableName = reader.readString("a table section's own table name");
+	const schemaFlag = reader.readInt32(`table "${tableName}"'s own schema-presence flag`);
+	if (schemaFlag !== TABLE_INIT_WITH_SCHEMA && schemaFlag !== TABLE_INIT_WITHOUT_SCHEMA) throw new HsqldbBinaryScriptParseError(`table "${tableName}"'s init record has schema flag ${schemaFlag}, which is neither ${TABLE_INIT_WITHOUT_SCHEMA} nor ${TABLE_INIT_WITH_SCHEMA}`, reader.position);
+	if (schemaFlag === TABLE_INIT_WITH_SCHEMA) reader.readString(`table "${tableName}"'s own schema name`);
+	const table = tables.get(tableName.toUpperCase());
+	if (table === void 0) throw new HsqldbBinaryScriptParseError(`the data section declares rows for table "${tableName}", which the script's own DDL never declared`, reader.position);
+	const typeCodes = table.columns.map((column) => resolveHsqldbTypeCode(column.type));
+	const rows = [];
+	for (;;) {
+		const rowStart = reader.position;
+		const rowLength = reader.readInt32(`a row length in table "${tableName}"`);
+		if (rowLength === 0) break;
+		if (rowLength < 0) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" declares a negative length ${rowLength}`, rowStart);
+		const rowEnd = rowStart + rowLength;
+		reader.require(rowLength - 4, `a row in table "${tableName}"`);
+		rows.push(typeCodes.map((typeCode) => readHsqldbColumnValue(reader.cursor, typeCode, options)));
+		if (reader.position > rowEnd) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" overran its own declared length (consumed ${reader.position - rowStart} bytes, declared ${rowLength})`, reader.position);
+		reader.position = rowEnd;
+	}
+	const declaredRowCount = reader.readInt32(`table "${tableName}"'s own trailing row count`);
+	if (declaredRowCount !== rows.length) throw new HsqldbBinaryScriptParseError(`table "${tableName}" declares ${declaredRowCount} row(s) in its own terminator but the section carried ${rows.length}`, reader.position);
+	return {
+		tableName,
+		rows
+	};
+}
+function parseHsqldbBinaryScript(bytes, options) {
+	const reader = new BinaryScriptCursor(bytes);
+	const scriptText = readDdlStatements(reader).join("\n");
+	const tables = parseHsqldbScript(new TextEncoder().encode(scriptText));
+	const tablesByName = new Map(tables.map((table) => [table.tableName.toUpperCase(), table]));
+	const rowsByTable = /* @__PURE__ */ new Map();
+	for (;;) {
+		const section = readTableSection(reader, tablesByName, options);
+		if (section === void 0) break;
+		rowsByTable.set(section.tableName.toUpperCase(), section.rows);
+	}
+	return {
+		scriptText,
+		tables: tables.map((table) => {
+			const rows = rowsByTable.get(table.tableName.toUpperCase());
+			return rows === void 0 ? table : {
+				...table,
+				rows
+			};
+		})
+	};
+}
+function inflateHsqldbCompressedScript(bytes) {
+	return unzlibSync(bytes);
+}
+//#endregion
+export { HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/cache.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_hsqldb_rowformat = require("./rowformat.cjs");
 //#region src/hsqldb/cache.ts
 const SUPPORTED_COMPATIBLE_VERSION_PREFIXES = ["1.7.", "1.8."];
+const DISK_NODE_SIZE_BYTES = 16;
 function parseHsqldbProperties(text) {
 	const props = /* @__PURE__ */ new Map();
 	for (const rawLine of text.split("\n")) {
@@ -32,17 +33,22 @@ function parseHsqldbIndexRoots(scriptText) {
 		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 require_hsqldb_rowformat.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`);
+		if (tokens.length < 2) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has ${tokens.length} token(s) -- every such line carries at least one index root position followed by the table's own identity-sequence value`);
+		const indexCount = tokens.length - 1;
 		const rootToken = tokens[0] ?? "";
-		const rootPos = Number(rootToken);
-		if (!Number.isInteger(rootPos)) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has a non-integer root position "${rootToken}"`);
-		roots.set(tableName, rootPos);
+		const rootPosition = Number(rootToken);
+		if (!Number.isInteger(rootPosition)) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has a non-integer root position "${rootToken}"`);
+		roots.set(tableName, {
+			rootPosition,
+			indexCount
+		});
 	}
 	return roots;
 }
-function readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, columns) {
+function readHsqldbCachedTableRows(dataBytes, roots, cacheFileScale, columns, options) {
 	const typeCodes = columns.map((column) => require_hsqldb_rowformat.resolveHsqldbTypeCode(column.type));
 	const results = [];
+	const trailingNodeBytes = (roots.indexCount - 1) * DISK_NODE_SIZE_BYTES;
 	function visit(pos) {
 		if (pos <= 0) return;
 		const byteOffset = pos * cacheFileScale;
@@ -55,26 +61,27 @@ function readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, columns)
 		const iLeft = cursor.readInt32();
 		const iRight = cursor.readInt32();
 		cursor.readInt32();
+		cursor.position += trailingNodeBytes;
 		const values = columns.map((_column, index) => {
 			const typeCode = typeCodes[index];
 			if (typeCode === void 0) throw new require_hsqldb_rowformat.HsqldbRowFormatError("internal error: column/type-code alignment failure");
-			return require_hsqldb_rowformat.readHsqldbColumnValue(cursor, typeCode);
+			return require_hsqldb_rowformat.readHsqldbColumnValue(cursor, typeCode, options);
 		});
 		if (cursor.position > rowEnd) throw new require_hsqldb_rowformat.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);
+	visit(roots.rootPosition);
 	return results;
 }
-function decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText) {
+function decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText, options) {
 	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);
+		const tableRoots = roots.get(table.tableName.toUpperCase());
+		if (tableRoots === void 0) return table;
+		const rows = readHsqldbCachedTableRows(dataBytes, tableRoots, cacheFileScale, table.columns, options);
 		return {
 			...table,
 			rows

package/dist/hsqldb/cache.d.cts

@@ -1,3 +1,4 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
 import { HsqldbColumn, HsqldbTable } from "./script.cjs";
 import { ContentCellValue } from "document-schema.js";
 //#region src/hsqldb/cache.d.ts
@@ -6,8 +7,12 @@ interface HsqldbCacheFileInfo {
   readonly compatibleVersion: string | undefined;
 }
 declare function parseHsqldbProperties(text: string): HsqldbCacheFileInfo;
-declare function parseHsqldbIndexRoots(scriptText: string): ReadonlyMap<string, number>;
-declare function readHsqldbCachedTableRows(dataBytes: Uint8Array<ArrayBuffer>, rootPos: number, cacheFileScale: number, columns: readonly HsqldbColumn[]): (readonly ContentCellValue[])[];
-declare function decodeHsqldbCachedTables(tables: readonly HsqldbTable[], scriptText: string, dataBytes: Uint8Array<ArrayBuffer>, propertiesText: string): readonly HsqldbTable[];
+interface HsqldbTableIndexRoots {
+  readonly rootPosition: number;
+  readonly indexCount: number;
+}
+declare function parseHsqldbIndexRoots(scriptText: string): ReadonlyMap<string, HsqldbTableIndexRoots>;
+declare function readHsqldbCachedTableRows(dataBytes: Uint8Array<ArrayBuffer>, roots: HsqldbTableIndexRoots, cacheFileScale: number, columns: readonly HsqldbColumn[], options?: HsqldbDecodeOptions): (readonly ContentCellValue[])[];
+declare function decodeHsqldbCachedTables(tables: readonly HsqldbTable[], scriptText: string, dataBytes: Uint8Array<ArrayBuffer>, propertiesText: string, options?: HsqldbDecodeOptions): readonly HsqldbTable[];
 //#endregion
-export { HsqldbCacheFileInfo, decodeHsqldbCachedTables, parseHsqldbIndexRoots, parseHsqldbProperties, readHsqldbCachedTableRows };
+export { HsqldbCacheFileInfo, HsqldbTableIndexRoots, decodeHsqldbCachedTables, parseHsqldbIndexRoots, parseHsqldbProperties, readHsqldbCachedTableRows };