documents.js 1.57.0 → 1.58.0

package/dist/firebird/blr-types.js

@@ -0,0 +1,90 @@
+//#region src/firebird/blr-types.ts
+const BLR_SHORT = 7;
+const BLR_LONG = 8;
+const BLR_QUAD = 9;
+const BLR_FLOAT = 10;
+const BLR_D_FLOAT = 11;
+const BLR_SQL_DATE = 12;
+const BLR_SQL_TIME = 13;
+const BLR_TEXT = 14;
+const BLR_TEXT2 = 15;
+const BLR_INT64 = 16;
+const BLR_BOOL = 23;
+const BLR_DEC64 = 24;
+const BLR_DEC128 = 25;
+const BLR_INT128 = 26;
+const BLR_DOUBLE = 27;
+const BLR_SQL_TIME_TZ = 28;
+const BLR_TIMESTAMP_TZ = 29;
+const BLR_EX_TIME_TZ = 30;
+const BLR_EX_TIMESTAMP_TZ = 31;
+const BLR_TIMESTAMP = 35;
+const BLR_VARYING = 37;
+const BLR_VARYING2 = 38;
+const BLR_CSTRING = 40;
+const BLR_CSTRING2 = 41;
+const BLR_BLOB = 261;
+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
+export { BLR_BLOB, BLR_BOOL, BLR_CSTRING, BLR_CSTRING2, BLR_DEC128, BLR_DEC64, BLR_DOUBLE, BLR_D_FLOAT, BLR_EX_TIMESTAMP_TZ, BLR_EX_TIME_TZ, BLR_FLOAT, BLR_INT128, BLR_INT64, BLR_LONG, BLR_QUAD, BLR_SHORT, BLR_SQL_DATE, BLR_SQL_TIME, BLR_SQL_TIME_TZ, BLR_TEXT, BLR_TEXT2, BLR_TIMESTAMP, BLR_TIMESTAMP_TZ, BLR_VARYING, BLR_VARYING2, FirebirdUnsupportedFieldTypeError, decodeBlrType, describeFieldType };

package/dist/firebird/data.cjs

@@ -0,0 +1,231 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_firebird_reader = require("./reader.cjs");
+const require_firebird_date = require("./date.cjs");
+//#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 require_firebird_reader.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: require_firebird_date.formatFirebirdDate(days)
+			});
+			break;
+		}
+		case "sql_time": {
+			const ticks = xdr.readInt32() >>> 0;
+			rawValues.push({
+				kind: "time",
+				value: require_firebird_date.formatFirebirdTime(ticks)
+			});
+			break;
+		}
+		case "timestamp": {
+			const days = xdr.readInt32();
+			const ticks = xdr.readInt32() >>> 0;
+			rawValues.push({
+				kind: "date",
+				value: require_firebird_date.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
+exports.FirebirdCompositeRecordUnsupportedError = FirebirdCompositeRecordUnsupportedError;
+exports.FirebirdDataParseError = FirebirdDataParseError;
+exports.readRelationData = readRelationData;

package/dist/firebird/data.d.cts

@@ -0,0 +1,17 @@
+import { n as FirebirdBackupReader } from "../reader-DP0Mbaj4.cjs";
+import { n as FirebirdRelation } from "../schema-Acco3Ezi.cjs";
+import { ContentCellValue } from "document-schema.js";
+//#region src/firebird/data.d.ts
+declare class FirebirdDataParseError extends Error {
+  constructor(message: string);
+}
+declare class FirebirdCompositeRecordUnsupportedError extends Error {
+  readonly recordType: number;
+  constructor(recordType: number, context: string);
+}
+declare function readRelationData(reader: FirebirdBackupReader, schema: ReadonlyMap<string, FirebirdRelation>, compressed: boolean): {
+  relationName: string;
+  rows: ContentCellValue[][];
+};
+//#endregion
+export { FirebirdCompositeRecordUnsupportedError, FirebirdDataParseError, readRelationData };

package/dist/firebird/data.d.ts

@@ -0,0 +1,17 @@
+import { n as FirebirdBackupReader } from "../reader-DP0Mbaj4.js";
+import { n as FirebirdRelation } from "../schema-VkAA6pF5.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/firebird/data.d.ts
+declare class FirebirdDataParseError extends Error {
+  constructor(message: string);
+}
+declare class FirebirdCompositeRecordUnsupportedError extends Error {
+  readonly recordType: number;
+  constructor(recordType: number, context: string);
+}
+declare function readRelationData(reader: FirebirdBackupReader, schema: ReadonlyMap<string, FirebirdRelation>, compressed: boolean): {
+  relationName: string;
+  rows: ContentCellValue[][];
+};
+//#endregion
+export { FirebirdCompositeRecordUnsupportedError, FirebirdDataParseError, readRelationData };

package/dist/firebird/data.js

@@ -0,0 +1,228 @@
+import { XdrReader } from "./reader.js";
+import { formatFirebirdDate, formatFirebirdTime, formatFirebirdTimestamp } from "./date.js";
+//#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
+export { FirebirdCompositeRecordUnsupportedError, FirebirdDataParseError, readRelationData };

package/dist/firebird/date.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.decodeFirebirdDate = decodeFirebirdDate;
+exports.decodeFirebirdTime = decodeFirebirdTime;
+exports.formatFirebirdDate = formatFirebirdDate;
+exports.formatFirebirdTime = formatFirebirdTime;
+exports.formatFirebirdTimestamp = formatFirebirdTimestamp;

package/dist/firebird/date.d.cts

@@ -0,0 +1,17 @@
+//#region src/firebird/date.d.ts
+declare function decodeFirebirdDate(days: number): {
+  year: number;
+  month: number;
+  day: number;
+};
+declare function decodeFirebirdTime(ticks: number): {
+  hours: number;
+  minutes: number;
+  seconds: number;
+  fractions: number;
+};
+declare function formatFirebirdDate(days: number): string;
+declare function formatFirebirdTime(ticks: number): string;
+declare function formatFirebirdTimestamp(days: number, ticks: number): string;
+//#endregion
+export { decodeFirebirdDate, decodeFirebirdTime, formatFirebirdDate, formatFirebirdTime, formatFirebirdTimestamp };

package/dist/firebird/date.d.ts

@@ -0,0 +1,17 @@
+//#region src/firebird/date.d.ts
+declare function decodeFirebirdDate(days: number): {
+  year: number;
+  month: number;
+  day: number;
+};
+declare function decodeFirebirdTime(ticks: number): {
+  hours: number;
+  minutes: number;
+  seconds: number;
+  fractions: number;
+};
+declare function formatFirebirdDate(days: number): string;
+declare function formatFirebirdTime(ticks: number): string;
+declare function formatFirebirdTimestamp(days: number, ticks: number): string;
+//#endregion
+export { decodeFirebirdDate, decodeFirebirdTime, formatFirebirdDate, formatFirebirdTime, formatFirebirdTimestamp };