documents.js 1.97.11 → 1.98.1

package/dist/convert/convert.js

@@ -1,2 +1,310 @@
-import { A as pdfToOdg, B as xlsxToOds, C as odsToXlsx, D as odtToPdf, E as odtToOdp, F as pdfToXlsx, I as pptxToDocx, L as pptxToOdp, M as pdfToOds, N as pdfToOdt, O as pdfToDocx, P as pdfToPptx, R as pptxToPdf, S as odsToPdf, T as odtToMarkdown, V as xlsxToPdf, _ as odgToPdf, a as docxToPptx, b as odpToPdf, c as markdownToOdt, d as odbReportToDocx, f as odbReportToOdt, g as odfToPdf, h as odbToXlsx, i as docxToPdf, j as pdfToOdp, k as pdfToMarkdown, l as markdownToPdf, m as odbToCsv, n as docxToMarkdown, o as inlineOdmSectionToContentSection, p as odbReportToPdf, r as docxToOdt, s as markdownToDocx, t as OdmUnresolvedSectionError, u as markdownToXlsx, v as odmToPdf, w as odtToDocx, x as odpToPptx, y as odpToOdt, z as xlsxToMarkdown } from "../convert-ULGgwmSb.js";
+import { flipY } from "../model/geometry.js";
+import { resolveMetadataTimestamps } from "../model/metadata.js";
+import { buildDocxPackage } from "../edit/docx/content.js";
+import { buildOdtPackage } from "../edit/odt/content.js";
+import { extractSourceFonts } from "../fonts/registry.js";
+import { layoutFormula } from "../mathml/layout.js";
+import { readOdfFormulaContent } from "../odf/formula/read.js";
+import { readOdtContent } from "../odf/odt/read.js";
+import { convertWordprocessingToLayout } from "../layout/engine.js";
+import { throwIfAborted } from "../ports/abort.js";
+import { buildOdbTableCsv } from "../odb/csv.js";
+import { readOdbTables } from "../odb/read.js";
+import { odbTablesToSpreadsheetDocument } from "../odb/spreadsheet.js";
+import { convertDocument } from "./composition.js";
+import { buildXlsxPackage, encodePackage } from "ooxml.js";
+import { COLOR_BLACK, CONTENT_FORMAT_VERSION, DOCUMENT_PACKAGE_FORMAT_VERSION, LAYOUT_FORMAT_VERSION, PAGE_SIZE_A4 } from "document-schema.js";
+import { decodePackage as decodePackage$1, encodePackage as encodePackage$1, readOdfMetadata, readOdfParagraph, readOdfTable, readOdm } from "odf.js";
+import { createFontMeasurer, createFontRegistry, loadMathFont, writePdf } from "pdf-codec";
+//#region src/convert/convert.ts
+const mathMetricsAt = (sizePt) => loadMathFont().metricsAt(sizePt);
+function docxToPdf(bytes, options) {
+	return convertDocument("docx", "pdf", bytes, options);
+}
+function odtToPdf(bytes, options) {
+	return convertDocument("odt", "pdf", bytes, options);
+}
+function pptxToPdf(bytes, options) {
+	return convertDocument("pptx", "pdf", bytes, options);
+}
+function odpToPdf(bytes, options) {
+	return convertDocument("odp", "pdf", bytes, options);
+}
+function odsToPdf(bytes, options) {
+	return convertDocument("ods", "pdf", bytes, options);
+}
+function odgToPdf(bytes, options) {
+	return convertDocument("odg", "pdf", bytes, options);
+}
+function markdownToPdf(bytes, options) {
+	return convertDocument("markdown", "pdf", bytes, options);
+}
+const STANDALONE_FORMULA_SIZE_PT = 18;
+const STANDALONE_FORMULA_MARGIN_PT = 72;
+function odfToPdf(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const read = readOdfFormulaContent(pkg);
+	if (read.kind !== "formula") throw new Error("readOdfFormulaContent returned a non-formula ContentDocument");
+	const content = {
+		...read,
+		metadata: resolveMetadataTimestamps(read.metadata, options?.clock)
+	};
+	const metrics = loadMathFont().metricsAt(STANDALONE_FORMULA_SIZE_PT);
+	const { box } = layoutFormula(content.formula.mathml, {
+		metrics,
+		sizePt: STANDALONE_FORMULA_SIZE_PT,
+		color: COLOR_BLACK
+	});
+	const flipped = flipY({
+		xPt: STANDALONE_FORMULA_MARGIN_PT,
+		yPt: STANDALONE_FORMULA_MARGIN_PT,
+		widthPt: box.widthPt,
+		heightPt: box.heightPt
+	}, PAGE_SIZE_A4.heightPt);
+	const layout = {
+		formatVersion: LAYOUT_FORMAT_VERSION,
+		metadata: content.metadata,
+		pages: [{
+			widthPt: PAGE_SIZE_A4.widthPt,
+			heightPt: PAGE_SIZE_A4.heightPt,
+			items: []
+		}],
+		images: {}
+	};
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	throwIfAborted(options?.signal);
+	return writePdf(layout, {
+		signal: options?.signal,
+		formulas: [{
+			pageIndex: 0,
+			xPt: flipped.xPt,
+			yPt: flipped.yPt,
+			box
+		}]
+	});
+}
+function pdfToDocx(bytes, options) {
+	return convertDocument("pdf", "docx", bytes, options);
+}
+function pdfToPptx(bytes, options) {
+	return convertDocument("pdf", "pptx", bytes, options);
+}
+function pdfToOdt(bytes, options) {
+	return convertDocument("pdf", "odt", bytes, options);
+}
+function pdfToOdp(bytes, options) {
+	return convertDocument("pdf", "odp", bytes, options);
+}
+function pdfToOdg(bytes, options) {
+	return convertDocument("pdf", "odg", bytes, options);
+}
+function pdfToOds(bytes, options) {
+	return convertDocument("pdf", "ods", bytes, options);
+}
+function pdfToMarkdown(bytes, options) {
+	return convertDocument("pdf", "markdown", bytes, options);
+}
+function odtToDocx(bytes, options) {
+	return convertDocument("odt", "docx", bytes, options);
+}
+function docxToOdt(bytes, options) {
+	return convertDocument("docx", "odt", bytes, options);
+}
+function odpToPptx(bytes, options) {
+	return convertDocument("odp", "pptx", bytes, options);
+}
+function pptxToOdp(bytes, options) {
+	return convertDocument("pptx", "odp", bytes, options);
+}
+function odsToXlsx(bytes, options) {
+	return convertDocument("ods", "xlsx", bytes, options);
+}
+function xlsxToOds(bytes, options) {
+	return convertDocument("xlsx", "ods", bytes, options);
+}
+function markdownToDocx(bytes, options) {
+	return convertDocument("markdown", "docx", bytes, options);
+}
+function docxToMarkdown(bytes, options) {
+	return convertDocument("docx", "markdown", bytes, options);
+}
+function markdownToOdt(bytes, options) {
+	return convertDocument("markdown", "odt", bytes, options);
+}
+function odtToMarkdown(bytes, options) {
+	return convertDocument("odt", "markdown", bytes, options);
+}
+function docxToPptx(bytes, options) {
+	return convertDocument("docx", "pptx", bytes, options);
+}
+function pptxToDocx(bytes, options) {
+	return convertDocument("pptx", "docx", bytes, options);
+}
+function odtToOdp(bytes, options) {
+	return convertDocument("odt", "odp", bytes, options);
+}
+function odpToOdt(bytes, options) {
+	return convertDocument("odp", "odt", bytes, options);
+}
+function xlsxToPdf(bytes, options) {
+	return convertDocument("xlsx", "pdf", bytes, options);
+}
+function pdfToXlsx(bytes, options) {
+	return convertDocument("pdf", "xlsx", bytes, options);
+}
+function xlsxToMarkdown(bytes, options) {
+	return convertDocument("xlsx", "markdown", bytes, options);
+}
+function markdownToXlsx(bytes, options) {
+	return convertDocument("markdown", "xlsx", bytes, options);
+}
+var OdmUnresolvedSectionError = class extends Error {
+	hrefs;
+	constructor(hrefs) {
+		super(`odmToPdf: ${hrefs.length} chapter section(s) could not be resolved -- no inline content and no resolveSubDocument result for: ${hrefs.join(", ")}`);
+		this.name = "OdmUnresolvedSectionError";
+		this.hrefs = hrefs;
+	}
+};
+const INLINE_SECTION_MARGIN_PT = 56.69291338582677;
+const INLINE_SECTION_MARGINS = {
+	topPt: INLINE_SECTION_MARGIN_PT,
+	rightPt: INLINE_SECTION_MARGIN_PT,
+	bottomPt: INLINE_SECTION_MARGIN_PT,
+	leftPt: INLINE_SECTION_MARGIN_PT
+};
+function inlineOdmSectionToContentSection(section, pkg) {
+	const blocks = [];
+	for (const node of section.inlineContent ?? []) {
+		if (node.type !== "element") continue;
+		if (node.tag === "text:p" || node.tag === "text:h") blocks.push(readOdfParagraph(node, pkg));
+		else if (node.tag === "table:table") blocks.push(readOdfTable(node, pkg));
+	}
+	return {
+		pageSize: PAGE_SIZE_A4,
+		margins: INLINE_SECTION_MARGINS,
+		blocks
+	};
+}
+function withLeadingChapterBreak(section) {
+	const pageBreak = { kind: "pageBreak" };
+	return {
+		...section,
+		blocks: [pageBreak, ...section.blocks]
+	};
+}
+function odmToPdf(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const odm = readOdm(pkg);
+	const unresolvedHrefs = [];
+	const chapterSections = [];
+	const sourceFonts = extractSourceFonts({
+		kind: "odf",
+		package: pkg
+	});
+	for (const section of odm.sections) {
+		throwIfAborted(options?.signal);
+		if (section.inlineContent !== void 0) {
+			chapterSections.push([inlineOdmSectionToContentSection(section, pkg)]);
+			continue;
+		}
+		const chapterBytes = options?.resolveSubDocument?.(section.href);
+		if (chapterBytes === void 0) {
+			unresolvedHrefs.push(section.href);
+			continue;
+		}
+		const chapterPkg = decodePackage$1(chapterBytes);
+		sourceFonts.push(...extractSourceFonts({
+			kind: "odf",
+			package: chapterPkg
+		}));
+		const chapterContent = readOdtContent(chapterPkg);
+		if (chapterContent.kind !== "wordprocessing") throw new Error("readOdtContent returned a non-wordprocessing ContentDocument");
+		chapterSections.push(chapterContent.sections);
+	}
+	if (unresolvedHrefs.length > 0) throw new OdmUnresolvedSectionError(unresolvedHrefs);
+	const combinedSections = [];
+	chapterSections.forEach((sections, chapterIndex) => {
+		if (chapterIndex === 0) {
+			combinedSections.push(...sections);
+			return;
+		}
+		combinedSections.push(...sections.map((section, sectionIndex) => sectionIndex === 0 ? withLeadingChapterBreak(section) : section));
+	});
+	throwIfAborted(options?.signal);
+	const content = {
+		kind: "wordprocessing",
+		formatVersion: CONTENT_FORMAT_VERSION,
+		metadata: resolveMetadataTimestamps(readOdfMetadata(pkg), options?.clock),
+		sections: combinedSections
+	};
+	const fonts = createFontRegistry({
+		sourceFonts,
+		fonts: options?.fonts,
+		onSubstitution: options?.onFontSubstitution
+	});
+	const { document: layout, formulas } = convertWordprocessingToLayout(content, {
+		measurer: createFontMeasurer(fonts),
+		mathMetricsAt
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+}
+function odbToXlsx(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const tables = readOdbTables(pkg, { timeZone: options?.timeZone });
+	throwIfAborted(options?.signal);
+	const content = odbTablesToSpreadsheetDocument(tables);
+	return encodePackage(buildXlsxPackage(content));
+}
+function odbToCsv(bytes, options) {
+	throwIfAborted(options?.signal);
+	const pkg = decodePackage$1(bytes);
+	const tables = readOdbTables(pkg, { timeZone: options?.timeZone });
+	throwIfAborted(options?.signal);
+	return buildOdbTableCsv(tables, options?.table);
+}
+function odbReportToDocx(content, options) {
+	throwIfAborted(options?.signal);
+	return encodePackage(buildDocxPackage(content, { onMathDiagnostic: options?.onMathDiagnostic }));
+}
+function odbReportToOdt(content, options) {
+	throwIfAborted(options?.signal);
+	return encodePackage$1(buildOdtPackage(content));
+}
+function odbReportToPdf(content, options) {
+	throwIfAborted(options?.signal);
+	if (content.kind !== "wordprocessing") throw new Error("odbReportToPdf requires a wordprocessing ContentDocument");
+	const fonts = createFontRegistry({
+		fonts: options?.fonts,
+		onSubstitution: options?.onFontSubstitution
+	});
+	const { document: layout, formulas } = convertWordprocessingToLayout(content, {
+		measurer: createFontMeasurer(fonts),
+		mathMetricsAt
+	});
+	options?.onDocument?.({
+		formatVersion: DOCUMENT_PACKAGE_FORMAT_VERSION,
+		content,
+		layout
+	});
+	return writePdf(layout, {
+		signal: options?.signal,
+		onSubstitution: options?.onSubstitution,
+		formulas,
+		fonts
+	});
+}
+//#endregion
 export { OdmUnresolvedSectionError, docxToMarkdown, docxToOdt, docxToPdf, docxToPptx, inlineOdmSectionToContentSection, markdownToDocx, markdownToOdt, markdownToPdf, markdownToXlsx, odbReportToDocx, odbReportToOdt, odbReportToPdf, odbToCsv, odbToXlsx, odfToPdf, odgToPdf, odmToPdf, odpToOdt, odpToPdf, odpToPptx, odsToPdf, odsToXlsx, odtToDocx, odtToMarkdown, odtToOdp, odtToPdf, pdfToDocx, pdfToMarkdown, pdfToOdg, pdfToOdp, pdfToOds, pdfToOdt, pdfToPptx, pdfToXlsx, pptxToDocx, pptxToOdp, pptxToPdf, xlsxToMarkdown, xlsxToOds, xlsxToPdf };

package/dist/convert/local.cjs

@@ -1,10 +1,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_convert = require("../convert-BO_4tCwz.cjs");
+const require_convert_capability = require("./capability.cjs");
+const require_convert_port = require("./port.cjs");
+const require_convert_composition = require("./composition.cjs");
+const require_convert_convert = require("./convert.cjs");
 //#region src/convert/local.ts
-const SUPPORTED_CONVERSIONS = require_convert.DIRECT_EDGES.map((edge) => ({
-	source: edge.source,
-	target: edge.target
-}));
+const SUPPORTED_CONVERSIONS = (() => {
+	const pairs = [];
+	for (const source of require_convert_port.DOCUMENT_FORMATS) for (const target of require_convert_port.DOCUMENT_FORMATS) {
+		if (source === target) continue;
+		if (require_convert_composition.resolveCompositionPlan(source, target) !== void 0) pairs.push({
+			source,
+			target
+		});
+	}
+	pairs.push({
+		source: "odf",
+		target: "pdf"
+	});
+	pairs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+	return pairs;
+})();
 function substitutionDiagnostic(substitution, context) {
 	return {
 		severity: "info",
@@ -44,7 +59,7 @@ function createLocalDocumentConverter() {
 				options.onFontSubstitution?.(substitution);
 			};
 			if (source.format === "odf" && targetFormat === "pdf") {
-				const bytes = require_convert.odfToPdf(source.bytes, {
+				const bytes = require_convert_convert.odfToPdf(source.bytes, {
 					signal: options.signal,
 					fonts: options.fonts,
 					onFontSubstitution
@@ -58,8 +73,8 @@ function createLocalDocumentConverter() {
 					package: documentPackage
 				});
 			}
-			if (require_convert.resolveCompositionPlan(source.format, targetFormat) === void 0) return Promise.reject(new require_convert.UnsupportedConversionError(source.format, targetFormat));
-			const bytes = require_convert.convertDocument(source.format, targetFormat, source.bytes, {
+			if (require_convert_composition.resolveCompositionPlan(source.format, targetFormat) === void 0) return Promise.reject(new require_convert_capability.UnsupportedConversionError(source.format, targetFormat));
+			const bytes = require_convert_composition.convertDocument(source.format, targetFormat, source.bytes, {
 				signal: options.signal,
 				fonts: options.fonts,
 				onFontSubstitution,

package/dist/convert/local.js

@@ -1,9 +1,24 @@
-import { G as DIRECT_EDGES, U as convertDocument, W as resolveCompositionPlan, g as odfToPdf, q as UnsupportedConversionError } from "../convert-ULGgwmSb.js";
+import { UnsupportedConversionError } from "./capability.js";
+import { DOCUMENT_FORMATS } from "./port.js";
+import { convertDocument, resolveCompositionPlan } from "./composition.js";
+import { odfToPdf } from "./convert.js";
 //#region src/convert/local.ts
-const SUPPORTED_CONVERSIONS = DIRECT_EDGES.map((edge) => ({
-	source: edge.source,
-	target: edge.target
-}));
+const SUPPORTED_CONVERSIONS = (() => {
+	const pairs = [];
+	for (const source of DOCUMENT_FORMATS) for (const target of DOCUMENT_FORMATS) {
+		if (source === target) continue;
+		if (resolveCompositionPlan(source, target) !== void 0) pairs.push({
+			source,
+			target
+		});
+	}
+	pairs.push({
+		source: "odf",
+		target: "pdf"
+	});
+	pairs.sort((a, b) => a.source.localeCompare(b.source) || a.target.localeCompare(b.target));
+	return pairs;
+})();
 function substitutionDiagnostic(substitution, context) {
 	return {
 		severity: "info",

package/dist/fonts/registry.d.cts

@@ -1,2 +1,20 @@
-import { i as extractSourceFonts, n as FontSourcePackage, r as createDocumentFontRegistry, t as DocumentFontRegistryOptions } from "../registry-ZAWlWHqJ.cjs";
+import { FontSubstitution, ProvidedFont } from "document-schema.js";
+import { Package } from "ooxml.js";
+import { FontRegistry } from "pdf-codec";
+import { Package as Package$1 } from "odf.js";
+//#region src/fonts/registry.d.ts
+type FontSourcePackage = {
+  readonly kind: 'docx' | 'pptx';
+  readonly package: Package;
+} | {
+  readonly kind: 'odf';
+  readonly package: Package$1;
+};
+interface DocumentFontRegistryOptions {
+  readonly fonts?: readonly ProvidedFont[];
+  readonly onFontSubstitution?: (substitution: FontSubstitution) => void;
+}
+declare function extractSourceFonts(source: FontSourcePackage): ProvidedFont[];
+declare function createDocumentFontRegistry(source: FontSourcePackage, options?: DocumentFontRegistryOptions): FontRegistry;
+//#endregion
 export { DocumentFontRegistryOptions, FontSourcePackage, createDocumentFontRegistry, extractSourceFonts };

package/dist/fonts/registry.d.ts

@@ -1,2 +1,20 @@
-import { i as extractSourceFonts, n as FontSourcePackage, r as createDocumentFontRegistry, t as DocumentFontRegistryOptions } from "../registry-DpF4A9EM.js";
+import { Package } from "ooxml.js";
+import { FontSubstitution, ProvidedFont } from "document-schema.js";
+import { Package as Package$1 } from "odf.js";
+import { FontRegistry } from "pdf-codec";
+//#region src/fonts/registry.d.ts
+type FontSourcePackage = {
+  readonly kind: 'docx' | 'pptx';
+  readonly package: Package;
+} | {
+  readonly kind: 'odf';
+  readonly package: Package$1;
+};
+interface DocumentFontRegistryOptions {
+  readonly fonts?: readonly ProvidedFont[];
+  readonly onFontSubstitution?: (substitution: FontSubstitution) => void;
+}
+declare function extractSourceFonts(source: FontSourcePackage): ProvidedFont[];
+declare function createDocumentFontRegistry(source: FontSourcePackage, options?: DocumentFontRegistryOptions): FontRegistry;
+//#endregion
 export { DocumentFontRegistryOptions, FontSourcePackage, createDocumentFontRegistry, extractSourceFonts };

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

@@ -1,4 +1,4 @@
-import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
+import { HsqldbDecodeOptions } from "./rowformat.cjs";
 import { r as HsqldbTable } from "../script-DsGGIzGU.cjs";
 //#region src/hsqldb/binary-script.d.ts
 declare class HsqldbBinaryScriptParseError extends Error {

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

@@ -1,4 +1,4 @@
-import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
+import { HsqldbDecodeOptions } from "./rowformat.js";
 import { r as HsqldbTable } from "../script-DsGGIzGU.js";
 //#region src/hsqldb/binary-script.d.ts
 declare class HsqldbBinaryScriptParseError extends Error {

package/dist/hsqldb/cache.d.cts

@@ -1,4 +1,4 @@
-import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
+import { HsqldbDecodeOptions } from "./rowformat.cjs";
 import { r as HsqldbTable, t as HsqldbColumn } from "../script-DsGGIzGU.cjs";
 import { ContentCellValue } from "document-schema.js";
 //#region src/hsqldb/cache.d.ts

package/dist/hsqldb/cache.d.ts

@@ -1,4 +1,4 @@
-import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
+import { HsqldbDecodeOptions } from "./rowformat.js";
 import { r as HsqldbTable, t as HsqldbColumn } from "../script-DsGGIzGU.js";
 import { ContentCellValue } from "document-schema.js";
 //#region src/hsqldb/cache.d.ts

package/dist/hsqldb/rowformat.d.cts

@@ -1,2 +1,25 @@
-import { a as readModifiedUtf8, i as readHsqldbColumnValue, n as HsqldbDecodeOptions, o as resolveHsqldbTypeCode, r as HsqldbRowFormatError, t as HsqldbDataCursor } from "../rowformat-Cl2exlEh.cjs";
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/rowformat.d.ts
+declare class HsqldbRowFormatError extends Error {
+  constructor(message: string);
+}
+declare function resolveHsqldbTypeCode(declaredType: string): number;
+declare class HsqldbDataCursor {
+  private readonly bytes;
+  private readonly view;
+  position: number;
+  constructor(bytes: Uint8Array<ArrayBuffer>, offset?: number);
+  readUint8(): number;
+  readInt16(): number;
+  readInt32(): number;
+  readBigInt64(): bigint;
+  readFloat64(): number;
+  readBytes(length: number): Uint8Array<ArrayBuffer>;
+}
+declare function readModifiedUtf8(bytes: Uint8Array<ArrayBuffer>): string;
+interface HsqldbDecodeOptions {
+  readonly timeZone?: string;
+}
+declare function readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number, options?: HsqldbDecodeOptions): ContentCellValue;
+//#endregion
 export { HsqldbDataCursor, HsqldbDecodeOptions, HsqldbRowFormatError, readHsqldbColumnValue, readModifiedUtf8, resolveHsqldbTypeCode };

package/dist/hsqldb/rowformat.d.ts

@@ -1,2 +1,25 @@
-import { a as readModifiedUtf8, i as readHsqldbColumnValue, n as HsqldbDecodeOptions, o as resolveHsqldbTypeCode, r as HsqldbRowFormatError, t as HsqldbDataCursor } from "../rowformat-Cl2exlEh.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/rowformat.d.ts
+declare class HsqldbRowFormatError extends Error {
+  constructor(message: string);
+}
+declare function resolveHsqldbTypeCode(declaredType: string): number;
+declare class HsqldbDataCursor {
+  private readonly bytes;
+  private readonly view;
+  position: number;
+  constructor(bytes: Uint8Array<ArrayBuffer>, offset?: number);
+  readUint8(): number;
+  readInt16(): number;
+  readInt32(): number;
+  readBigInt64(): bigint;
+  readFloat64(): number;
+  readBytes(length: number): Uint8Array<ArrayBuffer>;
+}
+declare function readModifiedUtf8(bytes: Uint8Array<ArrayBuffer>): string;
+interface HsqldbDecodeOptions {
+  readonly timeZone?: string;
+}
+declare function readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number, options?: HsqldbDecodeOptions): ContentCellValue;
+//#endregion
 export { HsqldbDataCursor, HsqldbDecodeOptions, HsqldbRowFormatError, readHsqldbColumnValue, readModifiedUtf8, resolveHsqldbTypeCode };