documents.js 1.57.0 → 1.58.0

package/dist/hsqldb/cache.d.ts

@@ -0,0 +1,13 @@
+import { HsqldbColumn, HsqldbTable } from "./script.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/hsqldb/cache.d.ts
+interface HsqldbCacheFileInfo {
+  readonly cacheFileScale: number;
+  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[];
+//#endregion
+export { HsqldbCacheFileInfo, decodeHsqldbCachedTables, parseHsqldbIndexRoots, parseHsqldbProperties, readHsqldbCachedTableRows };

package/dist/hsqldb/cache.js

@@ -0,0 +1,84 @@
+import { HsqldbDataCursor, HsqldbRowFormatError, readHsqldbColumnValue, resolveHsqldbTypeCode } from "./rowformat.js";
+//#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
+export { decodeHsqldbCachedTables, parseHsqldbIndexRoots, parseHsqldbProperties, readHsqldbCachedTableRows };

package/dist/hsqldb/rowformat.cjs

@@ -0,0 +1,222 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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-schema.js 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(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(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function formatLocalTime(epochMillis) {
+	const date = epochMillisToLocalDate(epochMillis);
+	const base = `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(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(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(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
+exports.HsqldbDataCursor = HsqldbDataCursor;
+exports.HsqldbRowFormatError = HsqldbRowFormatError;
+exports.readHsqldbColumnValue = readHsqldbColumnValue;
+exports.resolveHsqldbTypeCode = resolveHsqldbTypeCode;

package/dist/hsqldb/rowformat.d.cts

@@ -0,0 +1,21 @@
+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 readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number): ContentCellValue;
+//#endregion
+export { HsqldbDataCursor, HsqldbRowFormatError, readHsqldbColumnValue, resolveHsqldbTypeCode };

package/dist/hsqldb/rowformat.d.ts

@@ -0,0 +1,21 @@
+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 readHsqldbColumnValue(cursor: HsqldbDataCursor, typeCode: number): ContentCellValue;
+//#endregion
+export { HsqldbDataCursor, HsqldbRowFormatError, readHsqldbColumnValue, resolveHsqldbTypeCode };

package/dist/hsqldb/rowformat.js

@@ -0,0 +1,218 @@
+//#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-schema.js 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(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(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function formatLocalTime(epochMillis) {
+	const date = epochMillisToLocalDate(epochMillis);
+	const base = `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(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(date.getMonth() + 1)}-${pad2(date.getDate())} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(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
+export { HsqldbDataCursor, HsqldbRowFormatError, readHsqldbColumnValue, resolveHsqldbTypeCode };