documents.js 1.57.1 → 1.58.0

package/dist/edit/pptx/slide.js

@@ -0,0 +1,145 @@
+import { el, txt } from "../../xml/fragment.js";
+import { removeChild } from "../../xml/edit.js";
+import { buildRelativeTarget } from "../../opc/paths.js";
+import { addRelationship } from "../../opc/rels.js";
+import { ensureContentTypeOverride } from "../../opc/content-types.js";
+import { encodeXmlText } from "../../xml/entities.js";
+import { DML_NS, NOTES_MASTER_REL_TYPE, PML_NS, buildEmptyGroupSpTree, ensureNotesMaster } from "./scaffold.js";
+import { PptxShape, buildTextBoxShape } from "./shape.js";
+import { insertPictureShapeMedia } from "./image.js";
+import { resolveRelationships, rootElement, textContent } from "ooxml.js";
+//#region src/edit/pptx/slide.ts
+function directChild(parent, tag) {
+	for (const child of parent.children) if (child.type === "element" && child.tag === tag) return child;
+}
+function findSpTree(slideRoot) {
+	const cSld = directChild(slideRoot, "p:cSld");
+	const spTree = cSld === void 0 ? void 0 : directChild(cSld, "p:spTree");
+	if (spTree === void 0) throw new Error("slide has no p:cSld/p:spTree element");
+	return spTree;
+}
+function nextIdIn(root) {
+	let max = 0;
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node === void 0) continue;
+		if (node.tag === "p:cNvPr") {
+			for (const a of node.attributes) if (a.name === "id") {
+				const n = Number.parseInt(a.value, 10);
+				if (!Number.isNaN(n) && n > max) max = n;
+			}
+		}
+		for (const child of node.children) if (child.type === "element") stack.push(child);
+	}
+	return max + 1;
+}
+const NOTES_SLIDE_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/notesSlide";
+const NOTES_SLIDE_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml";
+function buildMinimalNotesSlide(text) {
+	const body = el("p:sp", {}, [
+		el("p:nvSpPr", {}, [
+			el("p:cNvPr", {
+				id: "2",
+				name: "Notes Placeholder"
+			}),
+			el("p:cNvSpPr", {}, [el("a:spLocks", { noGrp: "1" })]),
+			el("p:nvPr", {}, [el("p:ph", {
+				type: "body",
+				idx: "1"
+			})])
+		]),
+		el("p:spPr", {}, [el("a:xfrm", {}, [el("a:off", {
+			x: "685800",
+			y: "4400550"
+		}), el("a:ext", {
+			cx: "5486400",
+			cy: "4200525"
+		})])]),
+		el("p:txBody", {}, [
+			el("a:bodyPr"),
+			el("a:lstStyle"),
+			el("a:p", {}, [el("a:r", {}, [el("a:t", {}, [txt(encodeXmlText(text))])])])
+		])
+	]);
+	const spTree = buildEmptyGroupSpTree();
+	spTree.children.push(body);
+	return el("p:notes", {
+		"xmlns:p": PML_NS,
+		"xmlns:a": DML_NS
+	}, [el("p:cSld", {}, [spTree]), el("p:clrMapOvr", {}, [el("a:masterClrMapping")])]);
+}
+var PptxSlide = class {
+	container;
+	node;
+	context;
+	removed = false;
+	constructor(container, node, context) {
+		this.container = container;
+		this.node = node;
+		this.context = context;
+	}
+	live() {
+		if (this.removed) throw new Error("this PptxSlide has been removed from the presentation and can no longer be used");
+		return this.node;
+	}
+	shapes() {
+		const spTree = findSpTree(this.live());
+		const out = [];
+		for (const child of spTree.children) if (child.type === "element" && (child.tag === "p:sp" || child.tag === "p:pic")) out.push(new PptxShape(spTree.children, child));
+		return out;
+	}
+	addTextBox(init) {
+		const spTree = findSpTree(this.live());
+		const id = nextIdIn(spTree);
+		const shapeElement = buildTextBoxShape(init.frame, init.text, id);
+		spTree.children.push(shapeElement);
+		return new PptxShape(spTree.children, shapeElement);
+	}
+	addImage(init) {
+		const slideRoot = this.live();
+		const spTree = findSpTree(slideRoot);
+		const media = {
+			pkg: this.context.pkg,
+			partPath: this.context.slidePartPath,
+			mediaDir: this.context.mediaDir
+		};
+		const shapeElement = insertPictureShapeMedia(media, slideRoot, init.frame, init);
+		spTree.children.push(shapeElement);
+		return new PptxShape(spTree.children, shapeElement);
+	}
+	get notes() {
+		const notesRel = [...resolveRelationships(this.context.pkg, this.context.slidePartPath).values()].find((r) => r.type === NOTES_SLIDE_RELATIONSHIP_TYPE);
+		if (notesRel === void 0) return "";
+		const notesRoot = rootElement(this.context.pkg.parts[notesRel.target]);
+		return notesRoot === void 0 ? "" : textContent(notesRoot);
+	}
+	set notes(value) {
+		const { pkg, slidePartPath } = this.context;
+		const existingRel = [...resolveRelationships(pkg, slidePartPath).values()].find((r) => r.type === NOTES_SLIDE_RELATIONSHIP_TYPE);
+		let notesPartPath;
+		if (existingRel === void 0) {
+			notesPartPath = `ppt/notesSlides/notesSlide${Object.keys(pkg.parts).filter((p) => /^ppt\/notesSlides\/notesSlide\d+\.xml$/.test(p)).length + 1}.xml`;
+			ensureContentTypeOverride(pkg, notesPartPath, NOTES_SLIDE_CONTENT_TYPE);
+			addRelationship(pkg, slidePartPath, {
+				type: NOTES_SLIDE_RELATIONSHIP_TYPE,
+				target: buildRelativeTarget(slidePartPath, notesPartPath)
+			});
+			const notesMasterPartPath = ensureNotesMaster(pkg);
+			addRelationship(pkg, notesPartPath, {
+				type: NOTES_MASTER_REL_TYPE,
+				target: buildRelativeTarget(notesPartPath, notesMasterPartPath)
+			});
+		} else notesPartPath = existingRel.target;
+		pkg.parts[notesPartPath] = {
+			kind: "xml",
+			nodes: [buildMinimalNotesSlide(value)]
+		};
+	}
+	remove() {
+		removeChild(this.container, this.live());
+		this.removed = true;
+	}
+};
+//#endregion
+export { PptxSlide };

package/dist/firebird/backup.cjs

@@ -0,0 +1,150 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_firebird_reader = require("./reader.cjs");
+const require_firebird_schema = require("./schema.cjs");
+const require_firebird_data = require("./data.cjs");
+//#region src/firebird/backup.ts
+const REC_DATABASE = 1;
+const REC_RELATION = 3;
+const REC_RELATION_DATA = 8;
+const REC_END = 10;
+const REC_PHYSICAL_DB = 14;
+const FLAT_SKIPPABLE_RECORD_TYPES = /* @__PURE__ */ new Set([
+	2,
+	24,
+	31,
+	32,
+	33,
+	34,
+	35,
+	19,
+	20,
+	26,
+	12,
+	25,
+	36,
+	37,
+	39,
+	21,
+	22,
+	40,
+	41,
+	42,
+	43
+]);
+var FirebirdBackupFormatError = class extends Error {
+	constructor(message) {
+		super(`Firebird backup: ${message}`);
+		this.name = "FirebirdBackupFormatError";
+	}
+};
+const ATT_BACKUP_FORMAT = 2;
+const ATT_BACKUP_COMPRESS = 4;
+const ATT_BACKUP_TRANSPORTABLE = 5;
+const ATT_PAGE_SIZE = 5;
+function readBurpHeader(reader) {
+	let backupFormatVersion;
+	let transportable = false;
+	let compressed = false;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		switch (attribute) {
+			case ATT_BACKUP_FORMAT:
+				backupFormatVersion = reader.readInt32Attribute();
+				break;
+			case ATT_BACKUP_TRANSPORTABLE:
+				transportable = reader.readInt32Attribute() !== 0;
+				break;
+			case ATT_BACKUP_COMPRESS:
+				compressed = reader.readInt32Attribute() !== 0;
+				break;
+			default: reader.skipAttributeValue();
+		}
+	}
+	if (backupFormatVersion === void 0) throw new FirebirdBackupFormatError("the leading rec_burp record had no att_backup_format attribute -- not a recognisable gbak backup stream");
+	return {
+		backupFormatVersion,
+		transportable,
+		compressed
+	};
+}
+function readDatabaseHeader(reader) {
+	let pageSizeBytes;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		if (attribute === ATT_PAGE_SIZE) pageSizeBytes = reader.readInt32Attribute();
+		else reader.skipAttributeValue();
+	}
+	return { pageSizeBytes };
+}
+const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+function relationToColumns(relation) {
+	return relation.fields.filter((field) => !field.computed).map((field) => ({
+		name: field.name,
+		type: field.typeLabel
+	}));
+}
+function readFirebirdBackup(bytes) {
+	const reader = new require_firebird_reader.FirebirdBackupReader(bytes);
+	const leadingRecordType = reader.readTag();
+	if (leadingRecordType !== 0) throw new FirebirdBackupFormatError(`expected the stream to open with rec_burp (tag 0), found tag ${leadingRecordType} -- not a recognisable gbak backup stream`);
+	const { backupFormatVersion, transportable, compressed } = readBurpHeader(reader);
+	if (backupFormatVersion !== 10) throw new FirebirdBackupFormatError(`backup format version ${backupFormatVersion} is not supported -- this reader has only been built and verified against format version 10 (Firebird 3.0-era gbak output). Refusing to guess at a different format's own attribute/record shape rather than risk silently misdecoding it.`);
+	if (!transportable) throw new FirebirdBackupFormatError("backup is in non-transportable (native binary) row format (att_backup_transportable=false) -- this reader only decodes the transportable/XDR row encoding, the one every real fixture it was built against actually uses (gbak's own default).");
+	let pageSizeBytes;
+	const schema = /* @__PURE__ */ new Map();
+	const tablesInOrder = [];
+	const rowsByRelation = /* @__PURE__ */ new Map();
+	for (;;) {
+		const recordType = reader.readTag();
+		if (recordType === REC_END) break;
+		if (recordType === REC_DATABASE || recordType === REC_PHYSICAL_DB) {
+			pageSizeBytes = readDatabaseHeader(reader).pageSizeBytes ?? pageSizeBytes;
+			continue;
+		}
+		if (recordType === REC_RELATION) {
+			const relation = require_firebird_schema.readRelationSchema(reader, (nestedRecordType) => {
+				throw new require_firebird_data.FirebirdCompositeRecordUnsupportedError(nestedRecordType, "reading a relation's own schema (a rec_view child, most likely)");
+			});
+			schema.set(relation.name, relation);
+			tablesInOrder.push(relation.name);
+			continue;
+		}
+		if (recordType === REC_RELATION_DATA) {
+			const result = require_firebird_data.readRelationData(reader, schema, compressed);
+			rowsByRelation.set(result.relationName, result.rows);
+			continue;
+		}
+		if (FLAT_SKIPPABLE_RECORD_TYPES.has(recordType)) {
+			reader.skipFlatRecordAttributes();
+			continue;
+		}
+		throw new require_firebird_data.FirebirdCompositeRecordUnsupportedError(recordType, "walking the backup stream's own top-level record sequence");
+	}
+	const tables = tablesInOrder.map((name) => {
+		const relation = schema.get(name);
+		if (relation === void 0) throw new FirebirdBackupFormatError(`internal error: relation "${name}" missing from its own schema map`);
+		const rows = rowsByRelation.get(name) ?? [];
+		return {
+			tableName: relation.name,
+			columns: relationToColumns(relation),
+			rows
+		};
+	});
+	return {
+		summary: {
+			backupFormatVersion,
+			transportable,
+			compressed,
+			pageSizeBytes
+		},
+		tables
+	};
+}
+//#endregion
+exports.FirebirdBackupFormatError = FirebirdBackupFormatError;
+exports.FirebirdCompositeRecordUnsupportedError = require_firebird_data.FirebirdCompositeRecordUnsupportedError;
+exports.FirebirdSchemaParseError = require_firebird_schema.FirebirdSchemaParseError;
+exports.SUPPORTED_BACKUP_FORMAT_VERSION = SUPPORTED_BACKUP_FORMAT_VERSION;
+exports.readFirebirdBackup = readFirebirdBackup;

package/dist/firebird/backup.d.cts

@@ -0,0 +1,21 @@
+import { HsqldbTable } from "../hsqldb/script.cjs";
+import { r as FirebirdSchemaParseError } from "../schema-Acco3Ezi.cjs";
+import { FirebirdCompositeRecordUnsupportedError } from "./data.cjs";
+//#region src/firebird/backup.d.ts
+declare class FirebirdBackupFormatError extends Error {
+  constructor(message: string);
+}
+interface FirebirdBackupSummary {
+  readonly backupFormatVersion: number;
+  readonly transportable: boolean;
+  readonly compressed: boolean;
+  readonly pageSizeBytes: number | undefined;
+}
+declare const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+interface ReadFirebirdBackupResult {
+  readonly summary: FirebirdBackupSummary;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function readFirebirdBackup(bytes: Uint8Array<ArrayBuffer>): ReadFirebirdBackupResult;
+//#endregion
+export { FirebirdBackupFormatError, FirebirdBackupSummary, FirebirdCompositeRecordUnsupportedError, FirebirdSchemaParseError, ReadFirebirdBackupResult, SUPPORTED_BACKUP_FORMAT_VERSION, readFirebirdBackup };

package/dist/firebird/backup.d.ts

@@ -0,0 +1,21 @@
+import { HsqldbTable } from "../hsqldb/script.js";
+import { r as FirebirdSchemaParseError } from "../schema-VkAA6pF5.js";
+import { FirebirdCompositeRecordUnsupportedError } from "./data.js";
+//#region src/firebird/backup.d.ts
+declare class FirebirdBackupFormatError extends Error {
+  constructor(message: string);
+}
+interface FirebirdBackupSummary {
+  readonly backupFormatVersion: number;
+  readonly transportable: boolean;
+  readonly compressed: boolean;
+  readonly pageSizeBytes: number | undefined;
+}
+declare const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+interface ReadFirebirdBackupResult {
+  readonly summary: FirebirdBackupSummary;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function readFirebirdBackup(bytes: Uint8Array<ArrayBuffer>): ReadFirebirdBackupResult;
+//#endregion
+export { FirebirdBackupFormatError, FirebirdBackupSummary, FirebirdCompositeRecordUnsupportedError, FirebirdSchemaParseError, ReadFirebirdBackupResult, SUPPORTED_BACKUP_FORMAT_VERSION, readFirebirdBackup };

package/dist/firebird/backup.js

@@ -0,0 +1,145 @@
+import { FirebirdBackupReader } from "./reader.js";
+import { FirebirdSchemaParseError, readRelationSchema } from "./schema.js";
+import { FirebirdCompositeRecordUnsupportedError, readRelationData } from "./data.js";
+//#region src/firebird/backup.ts
+const REC_DATABASE = 1;
+const REC_RELATION = 3;
+const REC_RELATION_DATA = 8;
+const REC_END = 10;
+const REC_PHYSICAL_DB = 14;
+const FLAT_SKIPPABLE_RECORD_TYPES = /* @__PURE__ */ new Set([
+	2,
+	24,
+	31,
+	32,
+	33,
+	34,
+	35,
+	19,
+	20,
+	26,
+	12,
+	25,
+	36,
+	37,
+	39,
+	21,
+	22,
+	40,
+	41,
+	42,
+	43
+]);
+var FirebirdBackupFormatError = class extends Error {
+	constructor(message) {
+		super(`Firebird backup: ${message}`);
+		this.name = "FirebirdBackupFormatError";
+	}
+};
+const ATT_BACKUP_FORMAT = 2;
+const ATT_BACKUP_COMPRESS = 4;
+const ATT_BACKUP_TRANSPORTABLE = 5;
+const ATT_PAGE_SIZE = 5;
+function readBurpHeader(reader) {
+	let backupFormatVersion;
+	let transportable = false;
+	let compressed = false;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		switch (attribute) {
+			case ATT_BACKUP_FORMAT:
+				backupFormatVersion = reader.readInt32Attribute();
+				break;
+			case ATT_BACKUP_TRANSPORTABLE:
+				transportable = reader.readInt32Attribute() !== 0;
+				break;
+			case ATT_BACKUP_COMPRESS:
+				compressed = reader.readInt32Attribute() !== 0;
+				break;
+			default: reader.skipAttributeValue();
+		}
+	}
+	if (backupFormatVersion === void 0) throw new FirebirdBackupFormatError("the leading rec_burp record had no att_backup_format attribute -- not a recognisable gbak backup stream");
+	return {
+		backupFormatVersion,
+		transportable,
+		compressed
+	};
+}
+function readDatabaseHeader(reader) {
+	let pageSizeBytes;
+	for (;;) {
+		const attribute = reader.readTag();
+		if (attribute === 0) break;
+		if (attribute === ATT_PAGE_SIZE) pageSizeBytes = reader.readInt32Attribute();
+		else reader.skipAttributeValue();
+	}
+	return { pageSizeBytes };
+}
+const SUPPORTED_BACKUP_FORMAT_VERSION = 10;
+function relationToColumns(relation) {
+	return relation.fields.filter((field) => !field.computed).map((field) => ({
+		name: field.name,
+		type: field.typeLabel
+	}));
+}
+function readFirebirdBackup(bytes) {
+	const reader = new FirebirdBackupReader(bytes);
+	const leadingRecordType = reader.readTag();
+	if (leadingRecordType !== 0) throw new FirebirdBackupFormatError(`expected the stream to open with rec_burp (tag 0), found tag ${leadingRecordType} -- not a recognisable gbak backup stream`);
+	const { backupFormatVersion, transportable, compressed } = readBurpHeader(reader);
+	if (backupFormatVersion !== 10) throw new FirebirdBackupFormatError(`backup format version ${backupFormatVersion} is not supported -- this reader has only been built and verified against format version 10 (Firebird 3.0-era gbak output). Refusing to guess at a different format's own attribute/record shape rather than risk silently misdecoding it.`);
+	if (!transportable) throw new FirebirdBackupFormatError("backup is in non-transportable (native binary) row format (att_backup_transportable=false) -- this reader only decodes the transportable/XDR row encoding, the one every real fixture it was built against actually uses (gbak's own default).");
+	let pageSizeBytes;
+	const schema = /* @__PURE__ */ new Map();
+	const tablesInOrder = [];
+	const rowsByRelation = /* @__PURE__ */ new Map();
+	for (;;) {
+		const recordType = reader.readTag();
+		if (recordType === REC_END) break;
+		if (recordType === REC_DATABASE || recordType === REC_PHYSICAL_DB) {
+			pageSizeBytes = readDatabaseHeader(reader).pageSizeBytes ?? pageSizeBytes;
+			continue;
+		}
+		if (recordType === REC_RELATION) {
+			const relation = readRelationSchema(reader, (nestedRecordType) => {
+				throw new FirebirdCompositeRecordUnsupportedError(nestedRecordType, "reading a relation's own schema (a rec_view child, most likely)");
+			});
+			schema.set(relation.name, relation);
+			tablesInOrder.push(relation.name);
+			continue;
+		}
+		if (recordType === REC_RELATION_DATA) {
+			const result = readRelationData(reader, schema, compressed);
+			rowsByRelation.set(result.relationName, result.rows);
+			continue;
+		}
+		if (FLAT_SKIPPABLE_RECORD_TYPES.has(recordType)) {
+			reader.skipFlatRecordAttributes();
+			continue;
+		}
+		throw new FirebirdCompositeRecordUnsupportedError(recordType, "walking the backup stream's own top-level record sequence");
+	}
+	const tables = tablesInOrder.map((name) => {
+		const relation = schema.get(name);
+		if (relation === void 0) throw new FirebirdBackupFormatError(`internal error: relation "${name}" missing from its own schema map`);
+		const rows = rowsByRelation.get(name) ?? [];
+		return {
+			tableName: relation.name,
+			columns: relationToColumns(relation),
+			rows
+		};
+	});
+	return {
+		summary: {
+			backupFormatVersion,
+			transportable,
+			compressed,
+			pageSizeBytes
+		},
+		tables
+	};
+}
+//#endregion
+export { FirebirdBackupFormatError, FirebirdCompositeRecordUnsupportedError, FirebirdSchemaParseError, SUPPORTED_BACKUP_FORMAT_VERSION, readFirebirdBackup };

package/dist/firebird/blr-types.cjs

@@ -0,0 +1,118 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#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
+exports.BLR_BLOB = BLR_BLOB;
+exports.BLR_BOOL = BLR_BOOL;
+exports.BLR_CSTRING = BLR_CSTRING;
+exports.BLR_CSTRING2 = BLR_CSTRING2;
+exports.BLR_DEC128 = BLR_DEC128;
+exports.BLR_DEC64 = BLR_DEC64;
+exports.BLR_DOUBLE = BLR_DOUBLE;
+exports.BLR_D_FLOAT = BLR_D_FLOAT;
+exports.BLR_EX_TIMESTAMP_TZ = BLR_EX_TIMESTAMP_TZ;
+exports.BLR_EX_TIME_TZ = BLR_EX_TIME_TZ;
+exports.BLR_FLOAT = BLR_FLOAT;
+exports.BLR_INT128 = BLR_INT128;
+exports.BLR_INT64 = BLR_INT64;
+exports.BLR_LONG = BLR_LONG;
+exports.BLR_QUAD = BLR_QUAD;
+exports.BLR_SHORT = BLR_SHORT;
+exports.BLR_SQL_DATE = BLR_SQL_DATE;
+exports.BLR_SQL_TIME = BLR_SQL_TIME;
+exports.BLR_SQL_TIME_TZ = BLR_SQL_TIME_TZ;
+exports.BLR_TEXT = BLR_TEXT;
+exports.BLR_TEXT2 = BLR_TEXT2;
+exports.BLR_TIMESTAMP = BLR_TIMESTAMP;
+exports.BLR_TIMESTAMP_TZ = BLR_TIMESTAMP_TZ;
+exports.BLR_VARYING = BLR_VARYING;
+exports.BLR_VARYING2 = BLR_VARYING2;
+exports.FirebirdUnsupportedFieldTypeError = FirebirdUnsupportedFieldTypeError;
+exports.decodeBlrType = decodeBlrType;
+exports.describeFieldType = describeFieldType;

package/dist/firebird/blr-types.d.cts

@@ -0,0 +1,2 @@
+import { C as BLR_TIMESTAMP_TZ, D as FirebirdUnsupportedFieldTypeError, E as FirebirdPhysicalType, O as decodeBlrType, S as BLR_TIMESTAMP, T as BLR_VARYING2, _ as BLR_SQL_DATE, a as BLR_DEC128, b as BLR_TEXT, c as BLR_D_FLOAT, d as BLR_FLOAT, f as BLR_INT128, g as BLR_SHORT, h as BLR_QUAD, i as BLR_CSTRING2, k as describeFieldType, l as BLR_EX_TIMESTAMP_TZ, m as BLR_LONG, n as BLR_BOOL, o as BLR_DEC64, p as BLR_INT64, r as BLR_CSTRING, s as BLR_DOUBLE, t as BLR_BLOB, u as BLR_EX_TIME_TZ, v as BLR_SQL_TIME, w as BLR_VARYING, x as BLR_TEXT2, y as BLR_SQL_TIME_TZ } from "../blr-types-CYYC3yYU.cjs";
+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, FirebirdPhysicalType, FirebirdUnsupportedFieldTypeError, decodeBlrType, describeFieldType };

package/dist/firebird/blr-types.d.ts

@@ -0,0 +1,2 @@
+import { C as BLR_TIMESTAMP_TZ, D as FirebirdUnsupportedFieldTypeError, E as FirebirdPhysicalType, O as decodeBlrType, S as BLR_TIMESTAMP, T as BLR_VARYING2, _ as BLR_SQL_DATE, a as BLR_DEC128, b as BLR_TEXT, c as BLR_D_FLOAT, d as BLR_FLOAT, f as BLR_INT128, g as BLR_SHORT, h as BLR_QUAD, i as BLR_CSTRING2, k as describeFieldType, l as BLR_EX_TIMESTAMP_TZ, m as BLR_LONG, n as BLR_BOOL, o as BLR_DEC64, p as BLR_INT64, r as BLR_CSTRING, s as BLR_DOUBLE, t as BLR_BLOB, u as BLR_EX_TIME_TZ, v as BLR_SQL_TIME, w as BLR_VARYING, x as BLR_TEXT2, y as BLR_SQL_TIME_TZ } from "../blr-types-CYYC3yYU.js";
+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, FirebirdPhysicalType, FirebirdUnsupportedFieldTypeError, decodeBlrType, describeFieldType };