modern-pdf-lib 0.15.0 → 0.19.9

package/dist/{pdfPage-N1K2U3jI.mjs → pdfPage-BacMkrLe.mjs}

@@ -1,5 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
-import { a as formatPdfDate, c as PdfBool, f as PdfNumber, g as PdfString, h as PdfStream, l as PdfDict, s as PdfArray, u as PdfName } from "./pdfCatalog-BB2Wnmud.mjs";
+import { Ka as __exportAll } from "./index-BtYOx5wh.d.mts";
+import { i as PdfName, l as PdfStream, n as PdfBool, o as PdfNumber, r as PdfDict, t as PdfArray, u as PdfString } from "./pdfObjects-uEsWlfzU.mjs";
+import { a as formatPdfDate } from "./pdfCatalog-IImGcMbR.mjs";
 
 //#region src/core/operators/text.ts
 /**
@@ -3418,6 +3419,2973 @@ function buildPatternObjects(pattern, registry) {
 	};
 }
 
+//#endregion
+//#region src/barcode/qr.ts
+/** Characters valid in alphanumeric mode and their values. */
+const ALPHANUMERIC_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+/** Mode indicators (4-bit). */
+const MODE_NUMERIC = 1;
+const MODE_ALPHANUMERIC = 2;
+const MODE_BYTE = 4;
+/** EC level ordinal (used for table indexing). */
+const EC_ORDINAL = {
+	L: 0,
+	M: 1,
+	Q: 2,
+	H: 3
+};
+/**
+* Total data codewords per version/EC level.
+* Index: [version-1][ecOrdinal]
+*/
+const TOTAL_DATA_CODEWORDS = [
+	[
+		19,
+		16,
+		13,
+		9
+	],
+	[
+		34,
+		28,
+		22,
+		16
+	],
+	[
+		55,
+		44,
+		34,
+		26
+	],
+	[
+		80,
+		64,
+		48,
+		36
+	],
+	[
+		108,
+		86,
+		62,
+		46
+	],
+	[
+		136,
+		108,
+		76,
+		60
+	],
+	[
+		156,
+		124,
+		88,
+		66
+	],
+	[
+		194,
+		154,
+		110,
+		86
+	],
+	[
+		232,
+		182,
+		132,
+		100
+	],
+	[
+		274,
+		216,
+		154,
+		122
+	],
+	[
+		324,
+		254,
+		180,
+		140
+	],
+	[
+		370,
+		290,
+		206,
+		158
+	],
+	[
+		428,
+		334,
+		244,
+		180
+	],
+	[
+		461,
+		365,
+		261,
+		197
+	],
+	[
+		523,
+		415,
+		295,
+		223
+	],
+	[
+		589,
+		453,
+		325,
+		253
+	],
+	[
+		647,
+		507,
+		367,
+		283
+	],
+	[
+		721,
+		563,
+		397,
+		313
+	],
+	[
+		795,
+		627,
+		445,
+		341
+	],
+	[
+		861,
+		669,
+		485,
+		385
+	],
+	[
+		932,
+		714,
+		512,
+		406
+	],
+	[
+		1006,
+		782,
+		568,
+		442
+	],
+	[
+		1094,
+		860,
+		614,
+		464
+	],
+	[
+		1174,
+		914,
+		664,
+		514
+	],
+	[
+		1276,
+		1e3,
+		718,
+		538
+	],
+	[
+		1370,
+		1062,
+		754,
+		596
+	],
+	[
+		1468,
+		1128,
+		808,
+		628
+	],
+	[
+		1531,
+		1193,
+		871,
+		661
+	],
+	[
+		1631,
+		1267,
+		911,
+		701
+	],
+	[
+		1735,
+		1373,
+		985,
+		745
+	],
+	[
+		1843,
+		1455,
+		1033,
+		793
+	],
+	[
+		1955,
+		1541,
+		1115,
+		845
+	],
+	[
+		2071,
+		1631,
+		1171,
+		901
+	],
+	[
+		2191,
+		1725,
+		1231,
+		961
+	],
+	[
+		2306,
+		1812,
+		1286,
+		986
+	],
+	[
+		2434,
+		1914,
+		1354,
+		1054
+	],
+	[
+		2566,
+		1992,
+		1426,
+		1096
+	],
+	[
+		2702,
+		2102,
+		1502,
+		1142
+	],
+	[
+		2812,
+		2216,
+		1582,
+		1222
+	],
+	[
+		2956,
+		2334,
+		1666,
+		1276
+	]
+];
+/**
+* EC codewords per RS block for each version/EC level.
+* Index: [version-1][ecOrdinal]
+*/
+const EC_CODEWORDS_PER_BLOCK = [
+	[
+		7,
+		10,
+		13,
+		17
+	],
+	[
+		10,
+		16,
+		22,
+		28
+	],
+	[
+		15,
+		26,
+		18,
+		22
+	],
+	[
+		20,
+		18,
+		26,
+		16
+	],
+	[
+		26,
+		24,
+		18,
+		22
+	],
+	[
+		18,
+		16,
+		24,
+		28
+	],
+	[
+		20,
+		18,
+		18,
+		26
+	],
+	[
+		24,
+		22,
+		22,
+		26
+	],
+	[
+		30,
+		22,
+		20,
+		24
+	],
+	[
+		18,
+		26,
+		24,
+		28
+	],
+	[
+		20,
+		30,
+		28,
+		24
+	],
+	[
+		24,
+		22,
+		26,
+		28
+	],
+	[
+		26,
+		22,
+		24,
+		22
+	],
+	[
+		30,
+		24,
+		20,
+		24
+	],
+	[
+		22,
+		24,
+		30,
+		24
+	],
+	[
+		24,
+		28,
+		24,
+		30
+	],
+	[
+		28,
+		28,
+		28,
+		28
+	],
+	[
+		30,
+		26,
+		28,
+		28
+	],
+	[
+		28,
+		26,
+		26,
+		26
+	],
+	[
+		28,
+		26,
+		28,
+		28
+	],
+	[
+		28,
+		26,
+		30,
+		28
+	],
+	[
+		28,
+		28,
+		24,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		26,
+		28,
+		30,
+		30
+	],
+	[
+		28,
+		28,
+		28,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	],
+	[
+		30,
+		28,
+		30,
+		30
+	]
+];
+/**
+* Block structure: [group1Blocks, group1DataCW, group2Blocks, group2DataCW]
+* Index: [version-1][ecOrdinal]
+*/
+const BLOCK_STRUCTURE = [
+	[
+		[
+			1,
+			19,
+			0,
+			0
+		],
+		[
+			1,
+			16,
+			0,
+			0
+		],
+		[
+			1,
+			13,
+			0,
+			0
+		],
+		[
+			1,
+			9,
+			0,
+			0
+		]
+	],
+	[
+		[
+			1,
+			34,
+			0,
+			0
+		],
+		[
+			1,
+			28,
+			0,
+			0
+		],
+		[
+			1,
+			22,
+			0,
+			0
+		],
+		[
+			1,
+			16,
+			0,
+			0
+		]
+	],
+	[
+		[
+			1,
+			55,
+			0,
+			0
+		],
+		[
+			1,
+			44,
+			0,
+			0
+		],
+		[
+			2,
+			17,
+			0,
+			0
+		],
+		[
+			2,
+			13,
+			0,
+			0
+		]
+	],
+	[
+		[
+			1,
+			80,
+			0,
+			0
+		],
+		[
+			2,
+			32,
+			0,
+			0
+		],
+		[
+			2,
+			24,
+			0,
+			0
+		],
+		[
+			4,
+			9,
+			0,
+			0
+		]
+	],
+	[
+		[
+			1,
+			108,
+			0,
+			0
+		],
+		[
+			2,
+			43,
+			0,
+			0
+		],
+		[
+			2,
+			15,
+			2,
+			16
+		],
+		[
+			2,
+			11,
+			2,
+			12
+		]
+	],
+	[
+		[
+			2,
+			68,
+			0,
+			0
+		],
+		[
+			4,
+			27,
+			0,
+			0
+		],
+		[
+			4,
+			19,
+			0,
+			0
+		],
+		[
+			4,
+			15,
+			0,
+			0
+		]
+	],
+	[
+		[
+			2,
+			78,
+			0,
+			0
+		],
+		[
+			4,
+			31,
+			0,
+			0
+		],
+		[
+			2,
+			14,
+			4,
+			15
+		],
+		[
+			4,
+			13,
+			1,
+			14
+		]
+	],
+	[
+		[
+			2,
+			97,
+			0,
+			0
+		],
+		[
+			2,
+			38,
+			2,
+			39
+		],
+		[
+			4,
+			18,
+			2,
+			19
+		],
+		[
+			4,
+			14,
+			2,
+			15
+		]
+	],
+	[
+		[
+			2,
+			116,
+			0,
+			0
+		],
+		[
+			3,
+			36,
+			2,
+			37
+		],
+		[
+			4,
+			16,
+			4,
+			17
+		],
+		[
+			4,
+			12,
+			4,
+			13
+		]
+	],
+	[
+		[
+			2,
+			68,
+			2,
+			69
+		],
+		[
+			4,
+			43,
+			1,
+			44
+		],
+		[
+			6,
+			19,
+			2,
+			20
+		],
+		[
+			6,
+			15,
+			2,
+			16
+		]
+	],
+	[
+		[
+			4,
+			81,
+			0,
+			0
+		],
+		[
+			1,
+			50,
+			4,
+			51
+		],
+		[
+			4,
+			22,
+			4,
+			23
+		],
+		[
+			3,
+			12,
+			8,
+			13
+		]
+	],
+	[
+		[
+			2,
+			92,
+			2,
+			93
+		],
+		[
+			6,
+			36,
+			2,
+			37
+		],
+		[
+			4,
+			20,
+			6,
+			21
+		],
+		[
+			7,
+			14,
+			4,
+			15
+		]
+	],
+	[
+		[
+			4,
+			107,
+			0,
+			0
+		],
+		[
+			8,
+			37,
+			1,
+			38
+		],
+		[
+			8,
+			20,
+			4,
+			21
+		],
+		[
+			12,
+			11,
+			4,
+			12
+		]
+	],
+	[
+		[
+			3,
+			115,
+			1,
+			116
+		],
+		[
+			4,
+			40,
+			5,
+			41
+		],
+		[
+			11,
+			16,
+			5,
+			17
+		],
+		[
+			11,
+			12,
+			5,
+			13
+		]
+	],
+	[
+		[
+			5,
+			87,
+			1,
+			88
+		],
+		[
+			5,
+			41,
+			5,
+			42
+		],
+		[
+			5,
+			24,
+			7,
+			25
+		],
+		[
+			11,
+			12,
+			7,
+			13
+		]
+	],
+	[
+		[
+			5,
+			98,
+			1,
+			99
+		],
+		[
+			7,
+			45,
+			3,
+			46
+		],
+		[
+			15,
+			19,
+			2,
+			20
+		],
+		[
+			3,
+			15,
+			13,
+			16
+		]
+	],
+	[
+		[
+			1,
+			107,
+			5,
+			108
+		],
+		[
+			10,
+			46,
+			1,
+			47
+		],
+		[
+			1,
+			22,
+			15,
+			23
+		],
+		[
+			2,
+			14,
+			17,
+			15
+		]
+	],
+	[
+		[
+			5,
+			120,
+			1,
+			121
+		],
+		[
+			9,
+			43,
+			4,
+			44
+		],
+		[
+			17,
+			22,
+			1,
+			23
+		],
+		[
+			2,
+			14,
+			19,
+			15
+		]
+	],
+	[
+		[
+			3,
+			113,
+			4,
+			114
+		],
+		[
+			3,
+			44,
+			11,
+			45
+		],
+		[
+			17,
+			21,
+			4,
+			22
+		],
+		[
+			9,
+			13,
+			16,
+			14
+		]
+	],
+	[
+		[
+			3,
+			107,
+			5,
+			108
+		],
+		[
+			3,
+			41,
+			13,
+			42
+		],
+		[
+			15,
+			24,
+			5,
+			25
+		],
+		[
+			15,
+			15,
+			10,
+			16
+		]
+	],
+	[
+		[
+			4,
+			116,
+			4,
+			117
+		],
+		[
+			17,
+			42,
+			0,
+			0
+		],
+		[
+			17,
+			22,
+			6,
+			23
+		],
+		[
+			19,
+			16,
+			6,
+			17
+		]
+	],
+	[
+		[
+			2,
+			111,
+			7,
+			112
+		],
+		[
+			17,
+			46,
+			0,
+			0
+		],
+		[
+			7,
+			24,
+			16,
+			25
+		],
+		[
+			34,
+			13,
+			0,
+			0
+		]
+	],
+	[
+		[
+			4,
+			121,
+			5,
+			122
+		],
+		[
+			4,
+			47,
+			14,
+			48
+		],
+		[
+			11,
+			24,
+			14,
+			25
+		],
+		[
+			16,
+			15,
+			14,
+			16
+		]
+	],
+	[
+		[
+			6,
+			117,
+			4,
+			118
+		],
+		[
+			6,
+			45,
+			14,
+			46
+		],
+		[
+			11,
+			24,
+			16,
+			25
+		],
+		[
+			30,
+			16,
+			2,
+			17
+		]
+	],
+	[
+		[
+			8,
+			106,
+			4,
+			107
+		],
+		[
+			8,
+			47,
+			13,
+			48
+		],
+		[
+			7,
+			24,
+			22,
+			25
+		],
+		[
+			22,
+			15,
+			13,
+			16
+		]
+	],
+	[
+		[
+			10,
+			114,
+			2,
+			115
+		],
+		[
+			19,
+			46,
+			4,
+			47
+		],
+		[
+			28,
+			22,
+			6,
+			23
+		],
+		[
+			33,
+			16,
+			4,
+			17
+		]
+	],
+	[
+		[
+			8,
+			122,
+			4,
+			123
+		],
+		[
+			22,
+			45,
+			3,
+			46
+		],
+		[
+			8,
+			23,
+			26,
+			24
+		],
+		[
+			12,
+			15,
+			28,
+			16
+		]
+	],
+	[
+		[
+			3,
+			117,
+			10,
+			118
+		],
+		[
+			3,
+			45,
+			23,
+			46
+		],
+		[
+			4,
+			24,
+			31,
+			25
+		],
+		[
+			11,
+			15,
+			31,
+			16
+		]
+	],
+	[
+		[
+			7,
+			116,
+			7,
+			117
+		],
+		[
+			21,
+			45,
+			7,
+			46
+		],
+		[
+			1,
+			23,
+			37,
+			24
+		],
+		[
+			19,
+			15,
+			26,
+			16
+		]
+	],
+	[
+		[
+			5,
+			115,
+			10,
+			116
+		],
+		[
+			19,
+			47,
+			10,
+			48
+		],
+		[
+			15,
+			24,
+			25,
+			25
+		],
+		[
+			23,
+			15,
+			25,
+			16
+		]
+	],
+	[
+		[
+			13,
+			115,
+			3,
+			116
+		],
+		[
+			2,
+			46,
+			29,
+			47
+		],
+		[
+			42,
+			24,
+			1,
+			25
+		],
+		[
+			23,
+			15,
+			28,
+			16
+		]
+	],
+	[
+		[
+			17,
+			115,
+			0,
+			0
+		],
+		[
+			10,
+			46,
+			23,
+			47
+		],
+		[
+			10,
+			24,
+			35,
+			25
+		],
+		[
+			19,
+			15,
+			35,
+			16
+		]
+	],
+	[
+		[
+			17,
+			115,
+			1,
+			116
+		],
+		[
+			14,
+			46,
+			21,
+			47
+		],
+		[
+			29,
+			24,
+			19,
+			25
+		],
+		[
+			11,
+			15,
+			46,
+			16
+		]
+	],
+	[
+		[
+			13,
+			115,
+			6,
+			116
+		],
+		[
+			14,
+			46,
+			23,
+			47
+		],
+		[
+			44,
+			24,
+			7,
+			25
+		],
+		[
+			59,
+			16,
+			1,
+			17
+		]
+	],
+	[
+		[
+			12,
+			121,
+			7,
+			122
+		],
+		[
+			12,
+			47,
+			26,
+			48
+		],
+		[
+			39,
+			24,
+			14,
+			25
+		],
+		[
+			22,
+			15,
+			41,
+			16
+		]
+	],
+	[
+		[
+			6,
+			121,
+			14,
+			122
+		],
+		[
+			6,
+			47,
+			34,
+			48
+		],
+		[
+			46,
+			24,
+			10,
+			25
+		],
+		[
+			2,
+			15,
+			64,
+			16
+		]
+	],
+	[
+		[
+			17,
+			122,
+			4,
+			123
+		],
+		[
+			29,
+			46,
+			14,
+			47
+		],
+		[
+			49,
+			24,
+			10,
+			25
+		],
+		[
+			24,
+			15,
+			46,
+			16
+		]
+	],
+	[
+		[
+			4,
+			122,
+			18,
+			123
+		],
+		[
+			13,
+			46,
+			32,
+			47
+		],
+		[
+			48,
+			24,
+			14,
+			25
+		],
+		[
+			42,
+			15,
+			32,
+			16
+		]
+	],
+	[
+		[
+			20,
+			117,
+			4,
+			118
+		],
+		[
+			40,
+			47,
+			7,
+			48
+		],
+		[
+			43,
+			24,
+			22,
+			25
+		],
+		[
+			10,
+			15,
+			67,
+			16
+		]
+	],
+	[
+		[
+			19,
+			118,
+			6,
+			119
+		],
+		[
+			18,
+			47,
+			31,
+			48
+		],
+		[
+			34,
+			24,
+			34,
+			25
+		],
+		[
+			20,
+			15,
+			61,
+			16
+		]
+	]
+];
+const ALIGNMENT_POSITIONS = [
+	[],
+	[6, 18],
+	[6, 22],
+	[6, 26],
+	[6, 30],
+	[6, 34],
+	[
+		6,
+		22,
+		38
+	],
+	[
+		6,
+		24,
+		42
+	],
+	[
+		6,
+		26,
+		46
+	],
+	[
+		6,
+		28,
+		50
+	],
+	[
+		6,
+		30,
+		54
+	],
+	[
+		6,
+		32,
+		58
+	],
+	[
+		6,
+		34,
+		62
+	],
+	[
+		6,
+		26,
+		46,
+		66
+	],
+	[
+		6,
+		26,
+		48,
+		70
+	],
+	[
+		6,
+		26,
+		50,
+		74
+	],
+	[
+		6,
+		30,
+		54,
+		78
+	],
+	[
+		6,
+		30,
+		56,
+		82
+	],
+	[
+		6,
+		30,
+		58,
+		86
+	],
+	[
+		6,
+		34,
+		62,
+		90
+	],
+	[
+		6,
+		28,
+		50,
+		72,
+		94
+	],
+	[
+		6,
+		26,
+		50,
+		74,
+		98
+	],
+	[
+		6,
+		30,
+		54,
+		78,
+		102
+	],
+	[
+		6,
+		28,
+		54,
+		80,
+		106
+	],
+	[
+		6,
+		32,
+		58,
+		84,
+		110
+	],
+	[
+		6,
+		30,
+		58,
+		86,
+		114
+	],
+	[
+		6,
+		34,
+		62,
+		90,
+		118
+	],
+	[
+		6,
+		26,
+		50,
+		74,
+		98,
+		122
+	],
+	[
+		6,
+		30,
+		54,
+		78,
+		102,
+		126
+	],
+	[
+		6,
+		26,
+		52,
+		78,
+		104,
+		130
+	],
+	[
+		6,
+		30,
+		56,
+		82,
+		108,
+		134
+	],
+	[
+		6,
+		34,
+		60,
+		86,
+		112,
+		138
+	],
+	[
+		6,
+		30,
+		58,
+		86,
+		114,
+		142
+	],
+	[
+		6,
+		34,
+		62,
+		90,
+		118,
+		146
+	],
+	[
+		6,
+		30,
+		54,
+		78,
+		102,
+		126,
+		150
+	],
+	[
+		6,
+		24,
+		50,
+		76,
+		102,
+		128,
+		154
+	],
+	[
+		6,
+		28,
+		54,
+		80,
+		106,
+		132,
+		158
+	],
+	[
+		6,
+		32,
+		58,
+		84,
+		110,
+		136,
+		162
+	],
+	[
+		6,
+		26,
+		54,
+		82,
+		110,
+		138,
+		166
+	],
+	[
+		6,
+		30,
+		58,
+		86,
+		114,
+		142,
+		170
+	]
+];
+const FORMAT_INFO = [
+	30660,
+	29427,
+	32170,
+	30877,
+	26159,
+	25368,
+	27713,
+	26998,
+	21522,
+	20773,
+	24188,
+	23371,
+	17913,
+	16590,
+	20375,
+	19104,
+	13663,
+	12392,
+	16177,
+	14854,
+	9396,
+	8579,
+	11994,
+	11245,
+	5769,
+	5054,
+	7399,
+	6608,
+	1890,
+	597,
+	3340,
+	2107
+];
+const VERSION_INFO = [
+	31892,
+	34236,
+	39577,
+	42195,
+	48118,
+	51042,
+	55367,
+	58893,
+	63784,
+	68472,
+	70749,
+	76311,
+	79154,
+	84390,
+	87683,
+	92361,
+	96236,
+	102084,
+	102881,
+	110507,
+	110734,
+	117786,
+	119615,
+	126325,
+	127568,
+	133589,
+	136944,
+	141498
+];
+/** Log and antilog tables for GF(256) with primitive polynomial 0x11d. */
+const GF_EXP = new Uint8Array(512);
+const GF_LOG = new Uint8Array(256);
+{
+	let x = 1;
+	for (let i = 0; i < 255; i++) {
+		GF_EXP[i] = x;
+		GF_LOG[x] = i;
+		x <<= 1;
+		if (x >= 256) x ^= 285;
+	}
+	for (let i = 255; i < 512; i++) GF_EXP[i] = GF_EXP[i - 255];
+}
+/** Multiply two GF(256) elements. */
+function gfMul(a, b) {
+	if (a === 0 || b === 0) return 0;
+	return GF_EXP[(GF_LOG[a] + GF_LOG[b]) % 255];
+}
+/**
+* Generate a Reed-Solomon generator polynomial for `numEC` error
+* correction codewords. Returns coefficients in descending order.
+*/
+function rsGeneratorPoly(numEC) {
+	const gen = new Uint8Array(numEC + 1);
+	gen[0] = 1;
+	for (let i = 0; i < numEC; i++) {
+		for (let j = numEC; j >= 1; j--) gen[j] = gen[j - 1] ^ gfMul(gen[j], GF_EXP[i]);
+		gen[0] = gfMul(gen[0], GF_EXP[i]);
+	}
+	return gen;
+}
+/**
+* Compute Reed-Solomon error correction codewords for the given data.
+*/
+function rsEncode(data, numEC) {
+	const gen = rsGeneratorPoly(numEC);
+	const result = new Uint8Array(numEC);
+	for (let i = 0; i < data.length; i++) {
+		const coeff = data[i] ^ result[0];
+		for (let j = 0; j < numEC - 1; j++) result[j] = result[j + 1] ^ gfMul(coeff, gen[numEC - 1 - j]);
+		result[numEC - 1] = gfMul(coeff, gen[0]);
+	}
+	return result;
+}
+function detectMode(data) {
+	if (/^\d*$/.test(data)) return "numeric";
+	if (data.split("").every((ch) => ALPHANUMERIC_CHARS.includes(ch))) return "alphanumeric";
+	return "byte";
+}
+/** Number of bits for the character count indicator. */
+function charCountBits(version, mode) {
+	if (version <= 9) return mode === "numeric" ? 10 : mode === "alphanumeric" ? 9 : 8;
+	else if (version <= 26) return mode === "numeric" ? 12 : mode === "alphanumeric" ? 11 : 16;
+	else return mode === "numeric" ? 14 : mode === "alphanumeric" ? 13 : 16;
+}
+/** A simple bit buffer. */
+var BitBuffer = class {
+	bits = [];
+	get length() {
+		return this.bits.length;
+	}
+	put(value, numBits) {
+		for (let i = numBits - 1; i >= 0; i--) this.bits.push(value >>> i & 1);
+	}
+	getBit(index) {
+		return this.bits[index];
+	}
+	/** Convert to byte array (padded to full bytes with trailing zeros). */
+	toBytes() {
+		const byteLen = Math.ceil(this.bits.length / 8);
+		const bytes = new Uint8Array(byteLen);
+		for (let i = 0; i < this.bits.length; i++) if (this.bits[i]) bytes[i >>> 3] |= 128 >>> (i & 7);
+		return bytes;
+	}
+};
+/** Encode data into the bit buffer for the given mode. */
+function encodeData(data, mode, buf) {
+	switch (mode) {
+		case "numeric":
+			encodeNumeric(data, buf);
+			break;
+		case "alphanumeric":
+			encodeAlphanumeric(data, buf);
+			break;
+		case "byte":
+			encodeByte(data, buf);
+			break;
+	}
+}
+function encodeNumeric(data, buf) {
+	let i = 0;
+	while (i + 2 < data.length) {
+		const group = parseInt(data.substring(i, i + 3), 10);
+		buf.put(group, 10);
+		i += 3;
+	}
+	if (data.length - i === 2) buf.put(parseInt(data.substring(i, i + 2), 10), 7);
+	else if (data.length - i === 1) buf.put(parseInt(data.substring(i, i + 1), 10), 4);
+}
+function encodeAlphanumeric(data, buf) {
+	let i = 0;
+	while (i + 1 < data.length) {
+		const a = ALPHANUMERIC_CHARS.indexOf(data[i]);
+		const b = ALPHANUMERIC_CHARS.indexOf(data[i + 1]);
+		buf.put(a * 45 + b, 11);
+		i += 2;
+	}
+	if (i < data.length) buf.put(ALPHANUMERIC_CHARS.indexOf(data[i]), 6);
+}
+function encodeByte(data, buf) {
+	const bytes = new TextEncoder().encode(data);
+	for (const byte of bytes) buf.put(byte, 8);
+}
+/** Get the data length for character count purposes. */
+function getDataLength(data, mode) {
+	if (mode === "byte") return new TextEncoder().encode(data).length;
+	return data.length;
+}
+function modeIndicator(mode) {
+	switch (mode) {
+		case "numeric": return MODE_NUMERIC;
+		case "alphanumeric": return MODE_ALPHANUMERIC;
+		case "byte": return MODE_BYTE;
+	}
+}
+/**
+* Select the smallest QR version that can hold the data at the
+* given EC level.
+*/
+function selectVersion(data, mode, ecLevel) {
+	const ecOrd = EC_ORDINAL[ecLevel];
+	const dataLen = getDataLength(data, mode);
+	for (let version = 1; version <= 40; version++) {
+		const totalDataBits = TOTAL_DATA_CODEWORDS[version - 1][ecOrd] * 8;
+		const ccBits = charCountBits(version, mode);
+		let dataBits;
+		switch (mode) {
+			case "numeric":
+				dataBits = Math.floor(dataLen / 3) * 10 + (dataLen % 3 === 2 ? 7 : dataLen % 3 === 1 ? 4 : 0);
+				break;
+			case "alphanumeric":
+				dataBits = Math.floor(dataLen / 2) * 11 + (dataLen % 2 === 1 ? 6 : 0);
+				break;
+			case "byte":
+				dataBits = dataLen * 8;
+				break;
+		}
+		if (4 + ccBits + dataBits <= totalDataBits) return version;
+	}
+	throw new Error(`Data too long for QR code (max version 40 with EC level ${ecLevel})`);
+}
+function buildDataCodewords(data, mode, version, ecLevel) {
+	const ecOrd = EC_ORDINAL[ecLevel];
+	const totalDataBits = TOTAL_DATA_CODEWORDS[version - 1][ecOrd] * 8;
+	const buf = new BitBuffer();
+	buf.put(modeIndicator(mode), 4);
+	const dataLen = getDataLength(data, mode);
+	buf.put(dataLen, charCountBits(version, mode));
+	encodeData(data, mode, buf);
+	const terminatorLen = Math.min(4, totalDataBits - buf.length);
+	buf.put(0, terminatorLen);
+	while (buf.length % 8 !== 0) buf.put(0, 1);
+	const padBytes = [236, 17];
+	let padIdx = 0;
+	while (buf.length < totalDataBits) {
+		buf.put(padBytes[padIdx % 2], 8);
+		padIdx++;
+	}
+	return buf.toBytes();
+}
+function getBlockStructure(version, ecLevel) {
+	const ecOrd = EC_ORDINAL[ecLevel];
+	const bs = BLOCK_STRUCTURE[version - 1][ecOrd];
+	const blocks = [];
+	if (bs[0] > 0) blocks.push({
+		numBlocks: bs[0],
+		dataCodewords: bs[1]
+	});
+	if (bs[2] > 0) blocks.push({
+		numBlocks: bs[2],
+		dataCodewords: bs[3]
+	});
+	return blocks;
+}
+/**
+* Generate final codeword sequence (data + EC, interleaved).
+*/
+function generateCodewords(data, mode, version, ecLevel) {
+	const ecOrd = EC_ORDINAL[ecLevel];
+	const ecCWPerBlock = EC_CODEWORDS_PER_BLOCK[version - 1][ecOrd];
+	const blockGroups = getBlockStructure(version, ecLevel);
+	const dataCW = buildDataCodewords(data, mode, version, ecLevel);
+	const dataBlocks = [];
+	const ecBlocks = [];
+	let offset = 0;
+	for (const group of blockGroups) for (let b = 0; b < group.numBlocks; b++) {
+		const blockData = dataCW.slice(offset, offset + group.dataCodewords);
+		dataBlocks.push(blockData);
+		ecBlocks.push(rsEncode(blockData, ecCWPerBlock));
+		offset += group.dataCodewords;
+	}
+	const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+	const result = [];
+	for (let i = 0; i < maxDataLen; i++) for (const block of dataBlocks) if (i < block.length) result.push(block[i]);
+	for (let i = 0; i < ecCWPerBlock; i++) for (const block of ecBlocks) if (i < block.length) result.push(block[i]);
+	return new Uint8Array(result);
+}
+/** Matrix cell states. */
+const EMPTY = -1;
+const LIGHT = 0;
+const DARK = 1;
+function createMatrix(size) {
+	const matrix = new Int8Array(size * size);
+	matrix.fill(EMPTY);
+	return matrix;
+}
+function getCell(matrix, size, row, col) {
+	return matrix[row * size + col];
+}
+function setCell(matrix, size, row, col, value) {
+	matrix[row * size + col] = value;
+}
+/** Place a finder pattern with its top-left corner at (row, col). */
+function placeFinderPattern(matrix, size, row, col) {
+	for (let r = -1; r <= 7; r++) for (let c = -1; c <= 7; c++) {
+		const mr = row + r;
+		const mc = col + c;
+		if (mr < 0 || mr >= size || mc < 0 || mc >= size) continue;
+		if (r >= 0 && r <= 6 && (c === 0 || c === 6) || c >= 0 && c <= 6 && (r === 0 || r === 6) || r >= 2 && r <= 4 && c >= 2 && c <= 4) setCell(matrix, size, mr, mc, DARK);
+		else setCell(matrix, size, mr, mc, LIGHT);
+	}
+}
+/** Place an alignment pattern centred at (row, col). */
+function placeAlignmentPattern(matrix, size, centerRow, centerCol) {
+	for (let r = -2; r <= 2; r++) for (let c = -2; c <= 2; c++) {
+		const mr = centerRow + r;
+		const mc = centerCol + c;
+		if (mr < 0 || mr >= size || mc < 0 || mc >= size) continue;
+		if (Math.abs(r) === 2 || Math.abs(c) === 2 || r === 0 && c === 0) setCell(matrix, size, mr, mc, DARK);
+		else setCell(matrix, size, mr, mc, LIGHT);
+	}
+}
+/** Place timing patterns (row 6, col 6). */
+function placeTimingPatterns(matrix, size) {
+	for (let i = 8; i < size - 8; i++) {
+		const val = i % 2 === 0 ? DARK : LIGHT;
+		if (getCell(matrix, size, 6, i) === EMPTY) setCell(matrix, size, 6, i, val);
+		if (getCell(matrix, size, i, 6) === EMPTY) setCell(matrix, size, i, 6, val);
+	}
+}
+/** Reserve format information areas (set to LIGHT temporarily). */
+function reserveFormatAreas(matrix, size) {
+	for (let i = 0; i <= 8; i++) {
+		if (getCell(matrix, size, 8, i) === EMPTY) setCell(matrix, size, 8, i, LIGHT);
+		if (getCell(matrix, size, i, 8) === EMPTY) setCell(matrix, size, i, 8, LIGHT);
+	}
+	for (let i = 0; i <= 7; i++) if (getCell(matrix, size, size - 1 - i, 8) === EMPTY) setCell(matrix, size, size - 1 - i, 8, LIGHT);
+	for (let i = 0; i <= 7; i++) if (getCell(matrix, size, 8, size - 1 - i) === EMPTY) setCell(matrix, size, 8, size - 1 - i, LIGHT);
+	setCell(matrix, size, size - 8, 8, DARK);
+}
+/** Reserve version information areas (versions >= 7). */
+function reserveVersionAreas(matrix, size, version) {
+	if (version < 7) return;
+	for (let r = 0; r < 6; r++) for (let c = 0; c < 3; c++) if (getCell(matrix, size, size - 11 + c, r) === EMPTY) setCell(matrix, size, size - 11 + c, r, LIGHT);
+	for (let r = 0; r < 3; r++) for (let c = 0; c < 6; c++) if (getCell(matrix, size, r, size - 11 + c) === EMPTY) setCell(matrix, size, r, size - 11 + c, LIGHT);
+}
+/** Check if an alignment pattern centre conflicts with finder patterns. */
+function conflictsWithFinder(row, col, size) {
+	if (row <= 8 && col <= 8) return true;
+	if (row <= 8 && col >= size - 9) return true;
+	if (row >= size - 9 && col <= 8) return true;
+	return false;
+}
+/**
+* Place all function patterns on the matrix.
+*/
+function placeFunctionPatterns(matrix, size, version) {
+	placeFinderPattern(matrix, size, 0, 0);
+	placeFinderPattern(matrix, size, 0, size - 7);
+	placeFinderPattern(matrix, size, size - 7, 0);
+	placeTimingPatterns(matrix, size);
+	if (version >= 2) {
+		const positions = ALIGNMENT_POSITIONS[version - 1];
+		for (const row of positions) for (const col of positions) if (!conflictsWithFinder(row, col, size)) placeAlignmentPattern(matrix, size, row, col);
+	}
+	reserveFormatAreas(matrix, size);
+	reserveVersionAreas(matrix, size, version);
+}
+/**
+* Place data bits into the matrix, following the zigzag pattern
+* specified by ISO 18004.
+*/
+function placeDataBits(matrix, size, codewords) {
+	let bitIndex = 0;
+	const totalBits = codewords.length * 8;
+	let col = size - 1;
+	let goingUp = true;
+	while (col >= 0) {
+		if (col === 6) {
+			col--;
+			continue;
+		}
+		const startRow = goingUp ? size - 1 : 0;
+		const endRow = goingUp ? -1 : size;
+		const step = goingUp ? -1 : 1;
+		for (let row = startRow; row !== endRow; row += step) for (let dc = 0; dc <= 1; dc++) {
+			const c = col - dc;
+			if (c < 0) continue;
+			if (getCell(matrix, size, row, c) !== EMPTY) continue;
+			if (bitIndex < totalBits) {
+				const byteIdx = bitIndex >>> 3;
+				const bitPos = 7 - (bitIndex & 7);
+				const bit = codewords[byteIdx] >>> bitPos & 1;
+				setCell(matrix, size, row, c, bit ? DARK : LIGHT);
+				bitIndex++;
+			} else setCell(matrix, size, row, c, LIGHT);
+		}
+		col -= 2;
+		goingUp = !goingUp;
+	}
+}
+const MASK_FUNCTIONS = [
+	(r, c) => (r + c) % 2 === 0,
+	(r, _c) => r % 2 === 0,
+	(_r, c) => c % 3 === 0,
+	(r, c) => (r + c) % 3 === 0,
+	(r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+	(r, c) => r * c % 2 + r * c % 3 === 0,
+	(r, c) => (r * c % 2 + r * c % 3) % 2 === 0,
+	(r, c) => ((r + c) % 2 + r * c % 3) % 2 === 0
+];
+/**
+* Create a mask of which cells are data cells (not function patterns).
+*/
+function createFunctionPatternMask(size, version) {
+	const mask = new Uint8Array(size * size);
+	const tempMatrix = createMatrix(size);
+	placeFunctionPatterns(tempMatrix, size, version);
+	for (let i = 0; i < size * size; i++) mask[i] = tempMatrix[i] !== EMPTY ? 1 : 0;
+	return mask;
+}
+/**
+* Apply a mask pattern to the matrix, only affecting data cells.
+*/
+function applyMask(matrix, size, maskIndex, functionMask) {
+	const maskFn = MASK_FUNCTIONS[maskIndex];
+	for (let row = 0; row < size; row++) for (let col = 0; col < size; col++) {
+		const idx = row * size + col;
+		if (functionMask[idx]) continue;
+		if (maskFn(row, col)) matrix[idx] = matrix[idx] === DARK ? LIGHT : DARK;
+	}
+}
+function embedFormatInfo(matrix, size, ecLevel, maskIndex) {
+	const formatBits = FORMAT_INFO[EC_ORDINAL[ecLevel] * 8 + maskIndex];
+	const horizontalPositions = [
+		0,
+		1,
+		2,
+		3,
+		4,
+		5,
+		7,
+		8,
+		size - 8,
+		size - 7,
+		size - 6,
+		size - 5,
+		size - 4,
+		size - 3,
+		size - 2,
+		size - 1
+	];
+	for (let i = 0; i < 15; i++) {
+		const bit = formatBits >>> 14 - i & 1;
+		setCell(matrix, size, 8, horizontalPositions[i], bit ? DARK : LIGHT);
+	}
+	const verticalPositions = [
+		size - 1,
+		size - 2,
+		size - 3,
+		size - 4,
+		size - 5,
+		size - 6,
+		size - 7,
+		size - 8,
+		7,
+		5,
+		4,
+		3,
+		2,
+		1,
+		0
+	];
+	for (let i = 0; i < 15; i++) {
+		const bit = formatBits >>> 14 - i & 1;
+		setCell(matrix, size, verticalPositions[i], 8, bit ? DARK : LIGHT);
+	}
+}
+function embedVersionInfo(matrix, size, version) {
+	if (version < 7) return;
+	const versionBits = VERSION_INFO[version - 7];
+	for (let i = 0; i < 18; i++) {
+		const bit = versionBits >>> i & 1;
+		const row = Math.floor(i / 3);
+		const col = i % 3;
+		const value = bit ? DARK : LIGHT;
+		setCell(matrix, size, size - 11 + col, row, value);
+		setCell(matrix, size, row, size - 11 + col, value);
+	}
+}
+function computePenalty(matrix, size) {
+	let penalty = 0;
+	for (let row = 0; row < size; row++) {
+		let count = 1;
+		for (let col = 1; col < size; col++) if (getCell(matrix, size, row, col) === getCell(matrix, size, row, col - 1)) count++;
+		else {
+			if (count >= 5) penalty += count - 2;
+			count = 1;
+		}
+		if (count >= 5) penalty += count - 2;
+	}
+	for (let col = 0; col < size; col++) {
+		let count = 1;
+		for (let row = 1; row < size; row++) if (getCell(matrix, size, row, col) === getCell(matrix, size, row - 1, col)) count++;
+		else {
+			if (count >= 5) penalty += count - 2;
+			count = 1;
+		}
+		if (count >= 5) penalty += count - 2;
+	}
+	for (let row = 0; row < size - 1; row++) for (let col = 0; col < size - 1; col++) {
+		const val = getCell(matrix, size, row, col);
+		if (val === getCell(matrix, size, row, col + 1) && val === getCell(matrix, size, row + 1, col) && val === getCell(matrix, size, row + 1, col + 1)) penalty += 3;
+	}
+	for (let row = 0; row < size; row++) for (let col = 0; col <= size - 11; col++) {
+		if (getCell(matrix, size, row, col) === DARK && getCell(matrix, size, row, col + 1) === LIGHT && getCell(matrix, size, row, col + 2) === DARK && getCell(matrix, size, row, col + 3) === DARK && getCell(matrix, size, row, col + 4) === DARK && getCell(matrix, size, row, col + 5) === LIGHT && getCell(matrix, size, row, col + 6) === DARK && getCell(matrix, size, row, col + 7) === LIGHT && getCell(matrix, size, row, col + 8) === LIGHT && getCell(matrix, size, row, col + 9) === LIGHT && getCell(matrix, size, row, col + 10) === LIGHT) penalty += 40;
+		if (getCell(matrix, size, row, col) === LIGHT && getCell(matrix, size, row, col + 1) === LIGHT && getCell(matrix, size, row, col + 2) === LIGHT && getCell(matrix, size, row, col + 3) === LIGHT && getCell(matrix, size, row, col + 4) === DARK && getCell(matrix, size, row, col + 5) === LIGHT && getCell(matrix, size, row, col + 6) === DARK && getCell(matrix, size, row, col + 7) === DARK && getCell(matrix, size, row, col + 8) === DARK && getCell(matrix, size, row, col + 9) === LIGHT && getCell(matrix, size, row, col + 10) === DARK) penalty += 40;
+	}
+	for (let col = 0; col < size; col++) for (let row = 0; row <= size - 11; row++) {
+		if (getCell(matrix, size, row, col) === DARK && getCell(matrix, size, row + 1, col) === LIGHT && getCell(matrix, size, row + 2, col) === DARK && getCell(matrix, size, row + 3, col) === DARK && getCell(matrix, size, row + 4, col) === DARK && getCell(matrix, size, row + 5, col) === LIGHT && getCell(matrix, size, row + 6, col) === DARK && getCell(matrix, size, row + 7, col) === LIGHT && getCell(matrix, size, row + 8, col) === LIGHT && getCell(matrix, size, row + 9, col) === LIGHT && getCell(matrix, size, row + 10, col) === LIGHT) penalty += 40;
+		if (getCell(matrix, size, row, col) === LIGHT && getCell(matrix, size, row + 1, col) === LIGHT && getCell(matrix, size, row + 2, col) === LIGHT && getCell(matrix, size, row + 3, col) === LIGHT && getCell(matrix, size, row + 4, col) === DARK && getCell(matrix, size, row + 5, col) === LIGHT && getCell(matrix, size, row + 6, col) === DARK && getCell(matrix, size, row + 7, col) === DARK && getCell(matrix, size, row + 8, col) === DARK && getCell(matrix, size, row + 9, col) === LIGHT && getCell(matrix, size, row + 10, col) === DARK) penalty += 40;
+	}
+	let darkCount = 0;
+	const total = size * size;
+	for (let i = 0; i < total; i++) if (matrix[i] === DARK) darkCount++;
+	const percent = darkCount * 100 / total;
+	const prev5 = Math.floor(percent / 5) * 5;
+	const next5 = prev5 + 5;
+	const prevDiff = Math.abs(prev5 - 50) / 5;
+	const nextDiff = Math.abs(next5 - 50) / 5;
+	penalty += Math.min(prevDiff, nextDiff) * 10;
+	return penalty;
+}
+/**
+* Encode a string as a QR code matrix.
+*
+* @param data              The string to encode.
+* @param errorCorrection   Error correction level (default: `'M'`).
+* @returns                 A {@link QrCodeMatrix} with the encoded data.
+*/
+function encodeQrCode(data, errorCorrection = "M") {
+	const mode = detectMode(data);
+	const version = selectVersion(data, mode, errorCorrection);
+	const size = version * 4 + 17;
+	const codewords = generateCodewords(data, mode, version, errorCorrection);
+	const functionMask = createFunctionPatternMask(size, version);
+	let bestPenalty = Infinity;
+	let bestMatrix = null;
+	for (let maskIdx = 0; maskIdx < 8; maskIdx++) {
+		const matrix = createMatrix(size);
+		placeFunctionPatterns(matrix, size, version);
+		placeDataBits(matrix, size, codewords);
+		applyMask(matrix, size, maskIdx, functionMask);
+		embedFormatInfo(matrix, size, errorCorrection, maskIdx);
+		embedVersionInfo(matrix, size, version);
+		const penalty = computePenalty(matrix, size);
+		if (penalty < bestPenalty) {
+			bestPenalty = penalty;
+			bestMatrix = matrix;
+		}
+	}
+	const modules = new Array(size * size);
+	for (let i = 0; i < size * size; i++) modules[i] = bestMatrix[i] === DARK;
+	return {
+		size,
+		modules,
+		version
+	};
+}
+/**
+* Convert a {@link QrCodeMatrix} to PDF content-stream operators.
+*
+* The QR code is rendered as filled rectangles (one per dark module),
+* positioned at `(x, y)` in PDF user-space coordinates. The `y`
+* coordinate refers to the **bottom-left** corner of the QR code.
+*
+* @param matrix   The QR code matrix from {@link encodeQrCode}.
+* @param x        X position in PDF points.
+* @param y        Y position in PDF points.
+* @param options  Rendering options (module size, quiet zone, colours).
+* @returns        A string of PDF content-stream operators.
+*/
+function qrCodeToOperators(matrix, x, y, options = {}) {
+	const moduleSize = options.moduleSize ?? 2;
+	const quietZone = options.quietZone ?? 4;
+	const fgColor = options.color ?? {
+		type: "grayscale",
+		gray: 0
+	};
+	const bgColor = options.backgroundColor ?? {
+		type: "grayscale",
+		gray: 1
+	};
+	const totalSize = (matrix.size + 2 * quietZone) * moduleSize;
+	let ops = "";
+	ops += saveState();
+	ops += applyFillColor(bgColor);
+	ops += rectangle(x, y, totalSize, totalSize);
+	ops += fill();
+	ops += applyFillColor(fgColor);
+	for (let row = 0; row < matrix.size; row++) for (let col = 0; col < matrix.size; col++) if (matrix.modules[row * matrix.size + col]) {
+		const px = x + (quietZone + col) * moduleSize;
+		const py = y + (quietZone + matrix.size - 1 - row) * moduleSize;
+		ops += rectangle(px, py, moduleSize, moduleSize);
+	}
+	ops += fill();
+	ops += restoreState();
+	return ops;
+}
+
+//#endregion
+//#region src/layout/table.ts
+/**
+* @module layout/table
+*
+* Table layout engine for PDF rendering.
+*
+* Renders tables as native PDF vector graphics with cells,
+* borders, text, and basic styling. All output is a string of
+* raw PDF content-stream operators that can be appended directly
+* to a page's operator buffer.
+*
+* Supports colspan, rowspan, rich cell content (styled text runs),
+* text overflow modes (wrap, truncate, ellipsis, shrink), and
+* automatic page breaks with header-row repetition.
+*/
+function isNestedTable(content) {
+	return typeof content === "object" && content !== null && !Array.isArray(content) && content.type === "table";
+}
+function isTextRunArray(content) {
+	return Array.isArray(content);
+}
+function cellText(content) {
+	if (typeof content === "string") return content;
+	if (isTextRunArray(content)) return content.map((r) => r.text).join("");
+	return "";
+}
+function estimateContentWidth(content, defaultFontSize) {
+	if (typeof content === "string") return content.length * defaultFontSize * .5;
+	if (isTextRunArray(content)) {
+		let total = 0;
+		for (const run of content) total += run.text.length * (run.fontSize ?? defaultFontSize) * .5;
+		return total;
+	}
+	return 0;
+}
+function normalizeCell(cell) {
+	if (cell === void 0) return { content: "" };
+	if (typeof cell === "string") return { content: cell };
+	return cell;
+}
+function resolvePadding(padding, defaultPadding) {
+	if (padding === void 0) return {
+		top: defaultPadding,
+		right: defaultPadding,
+		bottom: defaultPadding,
+		left: defaultPadding
+	};
+	if (typeof padding === "number") return {
+		top: padding,
+		right: padding,
+		bottom: padding,
+		left: padding
+	};
+	return {
+		top: padding.top ?? defaultPadding,
+		right: padding.right ?? defaultPadding,
+		bottom: padding.bottom ?? defaultPadding,
+		left: padding.left ?? defaultPadding
+	};
+}
+function resolveColumnCount(options) {
+	let maxCols = 0;
+	for (const row of options.rows) {
+		let cols = 0;
+		for (const cell of row.cells) {
+			const c = normalizeCell(cell);
+			cols += c.colSpan ?? 1;
+		}
+		if (cols > maxCols) maxCols = cols;
+	}
+	return Math.max(maxCols, 1);
+}
+function parsePercentage(value) {
+	const trimmed = value.trim();
+	if (!trimmed.endsWith("%")) return NaN;
+	const num = Number(trimmed.slice(0, -1));
+	if (!Number.isFinite(num) || num < 0) return NaN;
+	return num / 100;
+}
+function estimateAutoFitWidth(colIndex, options, fontSize, defaultPadding) {
+	let maxWidth = 0;
+	for (const row of options.rows) {
+		let ci = 0;
+		for (const rawCell of row.cells) {
+			const cell = normalizeCell(rawCell);
+			const span = cell.colSpan ?? 1;
+			if (ci === colIndex && span === 1) {
+				const p = resolvePadding(cell.padding, defaultPadding);
+				const cellFontSize = cell.fontSize ?? fontSize;
+				const needed = estimateContentWidth(cell.content, cellFontSize) + p.left + p.right;
+				if (needed > maxWidth) maxWidth = needed;
+			}
+			ci += span;
+			if (ci > colIndex) break;
+		}
+	}
+	return maxWidth || defaultPadding * 2;
+}
+function resolveColumnWidths(options) {
+	const numCols = resolveColumnCount(options);
+	const tableWidth = options.width;
+	const fontSize = options.fontSize ?? 12;
+	const defaultPadding = options.padding ?? 4;
+	if (!options.columns || options.columns.length === 0) {
+		const colWidth = tableWidth / numCols;
+		return Array.from({ length: numCols }, () => colWidth);
+	}
+	const widths = new Array(numCols).fill(-1);
+	const modes = new Array(numCols).fill("flex");
+	let consumed = 0;
+	for (let i = 0; i < numCols; i++) {
+		const col = options.columns[i];
+		if (col?.width != null && col.width > 0) {
+			widths[i] = col.width;
+			modes[i] = "fixed";
+			consumed += col.width;
+		}
+	}
+	for (let i = 0; i < numCols; i++) {
+		if (modes[i] !== "flex") continue;
+		const col = options.columns[i];
+		if (col?.percentage != null) {
+			const fraction = parsePercentage(col.percentage);
+			if (Number.isFinite(fraction)) {
+				widths[i] = fraction * tableWidth;
+				modes[i] = "percentage";
+				consumed += widths[i];
+			}
+		}
+	}
+	for (let i = 0; i < numCols; i++) {
+		if (modes[i] !== "flex") continue;
+		if (options.columns[i]?.autoFit) {
+			widths[i] = estimateAutoFitWidth(i, options, fontSize, defaultPadding);
+			modes[i] = "autofit";
+			consumed += widths[i];
+		}
+	}
+	const flexIndices = [];
+	let totalFlex = 0;
+	for (let i = 0; i < numCols; i++) if (modes[i] === "flex") {
+		const weight = options.columns[i]?.flex ?? 1;
+		totalFlex += weight;
+		flexIndices.push(i);
+	}
+	const remaining = Math.max(0, tableWidth - consumed);
+	for (const idx of flexIndices) {
+		const weight = options.columns[idx]?.flex ?? 1;
+		widths[idx] = totalFlex > 0 ? weight / totalFlex * remaining : 0;
+	}
+	for (let i = 0; i < numCols; i++) {
+		const col = options.columns[i];
+		if (col?.minWidth != null && widths[i] < col.minWidth) widths[i] = col.minWidth;
+		if (col?.maxWidth != null && widths[i] > col.maxWidth) widths[i] = col.maxWidth;
+	}
+	return widths;
+}
+function computeNestedTableHeight(nested, width) {
+	const { result } = renderTable({
+		...nested.table,
+		x: 0,
+		y: 0,
+		width
+	});
+	return result.height;
+}
+function wrapTextInternal(text, maxWidth, fontSize) {
+	const charWidth = fontSize * .5;
+	const maxChars = Math.max(1, Math.floor(maxWidth / charWidth));
+	const lines = [];
+	const words = text.split(" ");
+	let currentLine = "";
+	for (const word of words) {
+		const candidate = currentLine ? currentLine + " " + word : word;
+		if (candidate.length > maxChars && currentLine) {
+			lines.push(currentLine);
+			currentLine = word;
+		} else currentLine = candidate;
+	}
+	if (currentLine) lines.push(currentLine);
+	return lines.length > 0 ? lines : [""];
+}
+function truncateWithEllipsis(text, maxWidth, fontSize) {
+	const charWidth = fontSize * .5;
+	const maxChars = Math.max(1, Math.floor(maxWidth / charWidth));
+	if (text.length <= maxChars) return text;
+	const cutoff = Math.max(0, maxChars - 3);
+	return text.slice(0, cutoff) + "...";
+}
+function shrinkFontSize(text, maxWidth, fontSize) {
+	if (text.length * fontSize * .5 <= maxWidth || text.length === 0) return fontSize;
+	const needed = maxWidth / (text.length * .5);
+	return Math.max(4, Math.min(fontSize, needed));
+}
+function resolveRowHeights(options, fontSize, defaultPadding, colWidths) {
+	return options.rows.map((row) => {
+		if (row.height) return row.height;
+		let maxHeight = defaultPadding * 2 + fontSize;
+		let colIdx = 0;
+		for (const rawCell of row.cells) {
+			const c = normalizeCell(rawCell);
+			const p = resolvePadding(c.padding, defaultPadding);
+			const span = c.colSpan ?? 1;
+			let cellWidth = 0;
+			for (let s = 0; s < span && colIdx + s < colWidths.length; s++) cellWidth += colWidths[colIdx + s];
+			if (isNestedTable(c.content)) {
+				const nestedWidth = cellWidth - p.left - p.right;
+				const nestedHeight = computeNestedTableHeight(c.content, Math.max(0, nestedWidth));
+				const h = p.top + p.bottom + nestedHeight;
+				if (h > maxHeight) maxHeight = h;
+			} else {
+				const cellFontSize = c.fontSize ?? fontSize;
+				const contentText = cellText(c.content);
+				if (c.overflow === "wrap" && contentText) {
+					const lines = wrapTextInternal(contentText, cellWidth - p.left - p.right, cellFontSize);
+					const lineHeight = cellFontSize * 1.2;
+					const h = p.top + p.bottom + lines.length * lineHeight;
+					if (h > maxHeight) maxHeight = h;
+				} else {
+					const h = p.top + p.bottom + cellFontSize;
+					if (h > maxHeight) maxHeight = h;
+				}
+			}
+			colIdx += span;
+		}
+		return maxHeight;
+	});
+}
+function buildOccupationGrid(rows, numCols) {
+	const grid = Array.from({ length: rows.length }, () => Array.from({ length: numCols }, () => null));
+	for (let r = 0; r < rows.length; r++) {
+		let logicalCol = 0;
+		for (const rawCell of rows[r].cells) {
+			while (logicalCol < numCols && grid[r][logicalCol] !== null) logicalCol++;
+			if (logicalCol >= numCols) break;
+			const cell = normalizeCell(rawCell);
+			const cs = Math.max(1, cell.colSpan ?? 1);
+			const rs = Math.max(1, cell.rowSpan ?? 1);
+			const entry = {
+				cell,
+				originRow: r,
+				originCol: logicalCol
+			};
+			for (let dr = 0; dr < rs; dr++) for (let dc = 0; dc < cs; dc++) {
+				const tr = r + dr;
+				const tc = logicalCol + dc;
+				if (tr < rows.length && tc < numCols) grid[tr][tc] = entry;
+			}
+			logicalCol += cs;
+		}
+	}
+	return grid;
+}
+function spanWidth(colWidths, startCol, span) {
+	let w = 0;
+	for (let i = 0; i < span && startCol + i < colWidths.length; i++) w += colWidths[startCol + i];
+	return w;
+}
+function spanHeight(rowHeights, startRow, span) {
+	let h = 0;
+	for (let i = 0; i < span && startRow + i < rowHeights.length; i++) h += rowHeights[startRow + i];
+	return h;
+}
+function columnX(baseX, colWidths, col) {
+	let x = baseX;
+	for (let i = 0; i < col; i++) x += colWidths[i];
+	return x;
+}
+function renderPlainTextOps(cell, text, cellX, cellY, cellWidth, cellHeight, fontName, fontSize, padding, textColor, colDef) {
+	let ops = "";
+	const cellTextColor = cell.textColor ?? textColor;
+	let cellFontSize = cell.fontSize ?? fontSize;
+	const align = cell.align ?? colDef?.align ?? "left";
+	const verticalAlign = cell.verticalAlign ?? "top";
+	const contentWidth = cellWidth - padding.left - padding.right;
+	const overflow = cell.overflow ?? "truncate";
+	if (overflow === "wrap") {
+		const lines = wrapTextInternal(text, contentWidth, cellFontSize);
+		const lineHeight = cellFontSize * 1.2;
+		let startY;
+		if (verticalAlign === "middle") {
+			const totalTextHeight = lines.length * lineHeight;
+			startY = cellY - cellHeight / 2 + totalTextHeight / 2 - cellFontSize;
+		} else if (verticalAlign === "bottom") startY = cellY - cellHeight + padding.bottom + (lines.length - 1) * lineHeight;
+		else startY = cellY - padding.top - cellFontSize;
+		ops += saveState();
+		ops += applyFillColor(cellTextColor);
+		for (let li = 0; li < lines.length; li++) {
+			const line = lines[li];
+			const approxLineWidth = line.length * cellFontSize * .5;
+			let textX;
+			if (align === "center") textX = cellX + padding.left + Math.max(0, contentWidth - approxLineWidth) / 2;
+			else if (align === "right") textX = cellX + cellWidth - padding.right - approxLineWidth;
+			else textX = cellX + padding.left;
+			const textY = startY - li * lineHeight;
+			ops += beginText();
+			ops += setFont(fontName, cellFontSize);
+			ops += moveText(textX, textY);
+			ops += showText(line);
+			ops += endText();
+		}
+		ops += restoreState();
+	} else {
+		let displayText = text;
+		if (overflow === "ellipsis") displayText = truncateWithEllipsis(text, contentWidth, cellFontSize);
+		else if (overflow === "shrink") cellFontSize = shrinkFontSize(text, contentWidth, cellFontSize);
+		const approxTextWidth = displayText.length * cellFontSize * .5;
+		let textX;
+		if (align === "center") textX = cellX + padding.left + Math.max(0, contentWidth - approxTextWidth) / 2;
+		else if (align === "right") textX = cellX + cellWidth - padding.right - approxTextWidth;
+		else textX = cellX + padding.left;
+		let textY;
+		if (verticalAlign === "middle") textY = cellY - cellHeight / 2 - cellFontSize / 2 + cellFontSize * .2;
+		else if (verticalAlign === "bottom") textY = cellY - cellHeight + padding.bottom;
+		else textY = cellY - padding.top - cellFontSize;
+		ops += saveState();
+		if (overflow === "truncate") {
+			ops += rectangle(cellX, cellY - cellHeight, cellWidth, cellHeight);
+			ops += clip();
+			ops += endPath();
+		}
+		ops += applyFillColor(cellTextColor);
+		ops += beginText();
+		ops += setFont(fontName, cellFontSize);
+		ops += moveText(textX, textY);
+		ops += showText(displayText);
+		ops += endText();
+		ops += restoreState();
+	}
+	return ops;
+}
+function renderCellOps(cell, cellX, cellY, cellWidth, cellHeight, fontName, fontSize, defaultPadding, borderWidth, borderColor, textColor, colDef) {
+	let ops = "";
+	const padding = resolvePadding(cell.padding, defaultPadding);
+	if (cell.backgroundColor) {
+		ops += saveState();
+		ops += applyFillColor(cell.backgroundColor);
+		ops += rectangle(cellX, cellY - cellHeight, cellWidth, cellHeight);
+		ops += fill();
+		ops += restoreState();
+	}
+	if (borderWidth > 0) {
+		ops += saveState();
+		ops += applyStrokeColor(borderColor);
+		ops += setLineWidth(borderWidth);
+		ops += rectangle(cellX, cellY - cellHeight, cellWidth, cellHeight);
+		ops += stroke();
+		ops += restoreState();
+	}
+	const content = cell.content;
+	if (isNestedTable(content)) {
+		const nestedWidth = cellWidth - padding.left - padding.right;
+		const nestedX = cellX + padding.left;
+		const nestedY = cellY - padding.top;
+		const { ops: nestedOps } = renderTable({
+			...content.table,
+			x: nestedX,
+			y: nestedY,
+			width: Math.max(0, nestedWidth)
+		});
+		ops += nestedOps;
+	} else if (isTextRunArray(content)) {
+		if (content.length > 0) {
+			const cellTextColor = cell.textColor ?? textColor;
+			const cellFontSize = cell.fontSize ?? fontSize;
+			const align = cell.align ?? colDef?.align ?? "left";
+			const verticalAlign = cell.verticalAlign ?? "top";
+			const approxTextWidth = estimateContentWidth(content, cellFontSize);
+			const contentWidth = cellWidth - padding.left - padding.right;
+			let textXPos;
+			if (align === "center") textXPos = cellX + padding.left + Math.max(0, contentWidth - approxTextWidth) / 2;
+			else if (align === "right") textXPos = cellX + cellWidth - padding.right - approxTextWidth;
+			else textXPos = cellX + padding.left;
+			let textYPos;
+			if (verticalAlign === "middle") textYPos = cellY - cellHeight / 2 - cellFontSize / 2 + cellFontSize * .2;
+			else if (verticalAlign === "bottom") textYPos = cellY - cellHeight + padding.bottom;
+			else textYPos = cellY - padding.top - cellFontSize;
+			ops += saveState();
+			ops += beginText();
+			ops += moveText(textXPos, textYPos);
+			for (const run of content) {
+				ops += applyFillColor(run.color ?? cellTextColor);
+				ops += setFont(run.fontName ?? fontName, run.fontSize ?? cellFontSize);
+				ops += showText(run.text);
+			}
+			ops += endText();
+			ops += restoreState();
+		}
+	} else {
+		const text = typeof content === "string" ? content : "";
+		if (text) ops += renderPlainTextOps(cell, text, cellX, cellY, cellWidth, cellHeight, fontName, fontSize, padding, textColor, colDef);
+	}
+	return ops;
+}
+function renderTable(options) {
+	const fontSize = options.fontSize ?? 12;
+	const defaultPadding = options.padding ?? 4;
+	const borderWidth = options.borderWidth ?? .5;
+	const borderColor = options.borderColor ?? {
+		type: "grayscale",
+		gray: 0
+	};
+	const textColor = options.textColor ?? {
+		type: "grayscale",
+		gray: 0
+	};
+	const fontName = options.fontName ?? "Helvetica";
+	const headerRows = options.headerRows ?? 0;
+	const colWidths = resolveColumnWidths(options);
+	const numCols = colWidths.length;
+	const rowHeights = resolveRowHeights(options, fontSize, defaultPadding, colWidths);
+	const grid = buildOccupationGrid(options.rows, numCols);
+	let ops = saveState();
+	let currentY = options.y;
+	for (let rowIdx = 0; rowIdx < options.rows.length; rowIdx++) {
+		const row = options.rows[rowIdx];
+		const rowHeight = rowHeights[rowIdx];
+		const isHeader = rowIdx < headerRows;
+		let effectiveRowBg = row.backgroundColor;
+		if (!effectiveRowBg) {
+			if (isHeader && options.headerBackgroundColor) effectiveRowBg = options.headerBackgroundColor;
+			else if (!isHeader && options.alternateRowColors) {
+				const dataRowIdx = rowIdx - headerRows;
+				effectiveRowBg = options.alternateRowColors[dataRowIdx % 2 === 0 ? 0 : 1];
+			}
+		}
+		if (effectiveRowBg) {
+			ops += saveState();
+			ops += applyFillColor(effectiveRowBg);
+			ops += rectangle(options.x, currentY - rowHeight, options.width, rowHeight);
+			ops += fill();
+			ops += restoreState();
+		}
+		const rowTextColor = isHeader && options.headerTextColor ? options.headerTextColor : textColor;
+		for (let colIdx = 0; colIdx < numCols; colIdx++) {
+			const entry = grid[rowIdx][colIdx];
+			if (!entry) continue;
+			if (entry.originRow !== rowIdx || entry.originCol !== colIdx) continue;
+			const cell = entry.cell;
+			const cs = Math.max(1, cell.colSpan ?? 1);
+			const rs = Math.max(1, cell.rowSpan ?? 1);
+			const cellX = columnX(options.x, colWidths, colIdx);
+			const cellWidth = spanWidth(colWidths, colIdx, cs);
+			const cellHeight = spanHeight(rowHeights, rowIdx, rs);
+			const colDef = options.columns?.[colIdx];
+			ops += renderCellOps(cell, cellX, currentY, cellWidth, cellHeight, fontName, fontSize, defaultPadding, borderWidth, borderColor, rowTextColor, colDef);
+		}
+		currentY -= rowHeight;
+	}
+	ops += restoreState();
+	const totalHeight = options.y - currentY;
+	return {
+		ops,
+		result: {
+			width: options.width,
+			height: totalHeight,
+			rowHeights,
+			columnWidths: colWidths,
+			pagesUsed: 1
+		}
+	};
+}
+/**
+* Render a table across multiple pages, breaking rows when content
+* would exceed the available vertical space.
+*
+* Header rows (specified by `options.headerRows`) are repeated at the
+* top of each new page. Rows are never split across pages.
+*/
+function renderMultiPageTable(options, bottomMargin = 40) {
+	const fontSize = options.fontSize ?? 12;
+	const defaultPadding = options.padding ?? 4;
+	const borderWidth = options.borderWidth ?? .5;
+	const borderColor = options.borderColor ?? {
+		type: "grayscale",
+		gray: 0
+	};
+	const textColor = options.textColor ?? {
+		type: "grayscale",
+		gray: 0
+	};
+	const fontName = options.fontName ?? "Helvetica";
+	const headerRowCount = options.headerRows ?? 0;
+	const colWidths = resolveColumnWidths(options);
+	const numCols = colWidths.length;
+	const rowHeights = resolveRowHeights(options, fontSize, defaultPadding, colWidths);
+	const grid = buildOccupationGrid(options.rows, numCols);
+	const pages = [];
+	let currentPageOps = saveState();
+	let currentY = options.y;
+	let totalHeight = 0;
+	function renderHeaders() {
+		for (let hIdx = 0; hIdx < headerRowCount && hIdx < options.rows.length; hIdx++) {
+			const hRow = options.rows[hIdx];
+			const hRowHeight = rowHeights[hIdx];
+			if (hRow.backgroundColor) {
+				currentPageOps += saveState();
+				currentPageOps += applyFillColor(hRow.backgroundColor);
+				currentPageOps += rectangle(options.x, currentY - hRowHeight, options.width, hRowHeight);
+				currentPageOps += fill();
+				currentPageOps += restoreState();
+			}
+			for (let colIdx = 0; colIdx < numCols; colIdx++) {
+				const entry = grid[hIdx][colIdx];
+				if (!entry) continue;
+				if (entry.originRow !== hIdx || entry.originCol !== colIdx) continue;
+				const cell = entry.cell;
+				const cs = Math.max(1, cell.colSpan ?? 1);
+				const rs = Math.min(Math.max(1, cell.rowSpan ?? 1), headerRowCount - hIdx);
+				const cellX = columnX(options.x, colWidths, colIdx);
+				const cellWidth = spanWidth(colWidths, colIdx, cs);
+				const cellHeight = spanHeight(rowHeights, hIdx, rs);
+				const colDef = options.columns?.[colIdx];
+				currentPageOps += renderCellOps(cell, cellX, currentY, cellWidth, cellHeight, fontName, fontSize, defaultPadding, borderWidth, borderColor, textColor, colDef);
+			}
+			currentY -= hRowHeight;
+		}
+	}
+	function startNewPage() {
+		currentPageOps += restoreState();
+		pages.push({
+			ops: currentPageOps,
+			pageIndex: pages.length
+		});
+		currentPageOps = saveState();
+		currentY = options.y;
+		renderHeaders();
+	}
+	for (let rowIdx = 0; rowIdx < options.rows.length; rowIdx++) {
+		const row = options.rows[rowIdx];
+		const rowHeight = rowHeights[rowIdx];
+		if (currentY - rowHeight < bottomMargin && rowIdx > 0) {
+			startNewPage();
+			if (rowIdx < headerRowCount) continue;
+		}
+		if (row.backgroundColor) {
+			currentPageOps += saveState();
+			currentPageOps += applyFillColor(row.backgroundColor);
+			currentPageOps += rectangle(options.x, currentY - rowHeight, options.width, rowHeight);
+			currentPageOps += fill();
+			currentPageOps += restoreState();
+		}
+		for (let colIdx = 0; colIdx < numCols; colIdx++) {
+			const entry = grid[rowIdx][colIdx];
+			if (!entry) continue;
+			if (entry.originRow !== rowIdx || entry.originCol !== colIdx) continue;
+			const cell = entry.cell;
+			const cs = Math.max(1, cell.colSpan ?? 1);
+			const rs = Math.max(1, cell.rowSpan ?? 1);
+			const cellX = columnX(options.x, colWidths, colIdx);
+			const cellWidth = spanWidth(colWidths, colIdx, cs);
+			const cellHeight = spanHeight(rowHeights, rowIdx, rs);
+			const colDef = options.columns?.[colIdx];
+			currentPageOps += renderCellOps(cell, cellX, currentY, cellWidth, cellHeight, fontName, fontSize, defaultPadding, borderWidth, borderColor, textColor, colDef);
+		}
+		currentY -= rowHeight;
+		totalHeight += rowHeight;
+	}
+	currentPageOps += restoreState();
+	pages.push({
+		ops: currentPageOps,
+		pageIndex: pages.length
+	});
+	return {
+		pages,
+		result: {
+			width: options.width,
+			height: totalHeight,
+			rowHeights,
+			columnWidths: colWidths,
+			pagesUsed: pages.length
+		}
+	};
+}
+
 //#endregion
 //#region src/core/pdfPageText.ts
 /**
@@ -4655,6 +7623,58 @@ var PdfPage = class PdfPage {
 		this.ops += restoreState();
 	}
 	/**
+	* Draw a QR code at the specified position.
+	*
+	* The QR code is rendered as native PDF vector graphics (filled
+	* rectangles for each dark module), producing resolution-independent
+	* output.
+	*
+	* @param data     The string to encode in the QR code.
+	* @param options  Position, error correction level, colours, module size.
+	*/
+	drawQrCode(data, options = {}) {
+		const x = options.x ?? this._cursorX;
+		const y = options.y ?? this._cursorY;
+		const ops = qrCodeToOperators(encodeQrCode(data, options.errorCorrection ?? "M"), x, y, {
+			...options.moduleSize !== void 0 && { moduleSize: options.moduleSize },
+			...options.quietZone !== void 0 && { quietZone: options.quietZone },
+			...options.color !== void 0 && { color: options.color },
+			...options.backgroundColor !== void 0 && { backgroundColor: options.backgroundColor }
+		});
+		this.ops += ops;
+	}
+	/**
+	* Draw a table on this page.
+	*
+	* The table is rendered as native PDF vector graphics (rectangles,
+	* borders, and text operators).  The top-left corner of the table is
+	* at `(options.x, options.y)` and rows extend downward.
+	*
+	* @param options  Table configuration: position, size, rows, columns,
+	*                 fonts, colours, borders, and padding.
+	* @returns        A {@link TableRenderResult} with the computed
+	*                 dimensions and layout metrics.
+	*
+	* @example
+	* ```ts
+	* const result = page.drawTable({
+	*   x: 50,
+	*   y: 700,
+	*   width: 500,
+	*   rows: [
+	*     { cells: ['Name', 'Age', 'City'] },
+	*     { cells: ['Alice', '30', 'London'] },
+	*     { cells: ['Bob', '25', 'Paris'] },
+	*   ],
+	* });
+	* ```
+	*/
+	drawTable(options) {
+		const { ops, result } = renderTable(options);
+		this.ops += ops;
+		return result;
+	}
+	/**
 	* Draw a gradient fill (linear or radial) clipped to a rectangle.
 	*
 	* The gradient is registered as a `/Pattern` resource on this page
@@ -4991,5 +8011,5 @@ var PdfPage = class PdfPage {
 };
 
 //#endregion
-export { colorToComponents as $, setTextMatrix as $t, beginMarkedContent as A, fill as At, radians as B, setLineJoin as Bt, AnnotationFlags as C, closeFillEvenOddAndStroke as Ct, createAnnotation as D, curveToInitial as Dt, buildAnnotationDict as E, curveToFinal as Et, endMarkedContent as F, moveTo as Ft, saveState as G, endText as Gt, restoreState as H, setMiterLimit as Ht, wrapInMarkedContent as I, rectangle as It, skew as J, nextLine as Jt, scale as K, moveText as Kt, concatMatrix as L, setDashPattern as Lt, beginMarkedContentWithProperties as M, fillEvenOdd as Mt, createMarkedContentScope as N, fillEvenOddAndStroke as Nt, beginArtifact as O, ellipsePath as Ot, endArtifact as P, lineTo as Pt, cmyk as Q, setLeading as Qt, degrees as R, setFlatness as Rt, parseSvgTransform as S, closeFillAndStroke as St, annotationFromDict as T, curveTo as Tt, rotate as U, stroke as Ut, radiansToDegrees as V, setLineWidth as Vt, rotationMatrix as W, beginText as Wt, applyFillColor as X, setFont as Xt, translate as Y, setCharacterSpacing as Yt, applyStrokeColor as Z, setFontSize as Zt, drawSvgOnPage as _, drawXObject as _t, buildGradientObjects as a, showTextHex as an, setFillColorCmyk as at, parseSvgColor as b, clipEvenOdd as bt, radialGradient as c, setFillingColor as ct, getRedactionMarks as d, setStrokeColorGray as dt, setTextRenderingMode as en, componentsToColor as et, markForRedaction as f, setStrokeColorRgb as ft, endLayerContent as g, drawImageXObject as gt, beginLayerContent as h, drawImageWithMatrix as ht, wrapText as i, showTextArray as in, setFillColor as it, beginMarkedContentSequence as j, fillAndStroke as jt, beginArtifactWithType as k, endPath as kt, tilingPattern as l, setStrokeColor as lt, PdfLayerManager as m, setStrokingColor as mt, PdfPage as n, setWordSpacing as nn, rgb as nt, buildPatternObjects as o, showTextNextLine as on, setFillColorGray as ot, PdfLayer as p, setStrokeColorSpace as pt, setGraphicsState as q, moveTextSetLeading as qt, pdfPage_exports as r, showText as rn, setColorSpace as rt, linearGradient as s, showTextWithSpacing as sn, setFillColorRgb as st, PageSizes as t, setTextRise as tn, grayscale as tt, applyRedactions as u, setStrokeColorCmyk as ut, svgToPdfOperators as v, circlePath as vt, PdfAnnotation as w, closePath as wt, parseSvgPath as x, closeAndStroke as xt, parseSvg as y, clip as yt, degreesToRadians as z, setLineCap as zt };
-//# sourceMappingURL=pdfPage-N1K2U3jI.mjs.map
+export { translate as $, setCharacterSpacing as $t, buildAnnotationDict as A, curveToFinal as At, wrapInMarkedContent as B, rectangle as Bt, parseSvg as C, clip as Ct, AnnotationFlags as D, closeFillEvenOddAndStroke as Dt, parseSvgTransform as E, closeFillAndStroke as Et, beginMarkedContentSequence as F, fillAndStroke as Ft, radiansToDegrees as G, setLineWidth as Gt, degrees as H, setFlatness as Ht, beginMarkedContentWithProperties as I, fillEvenOdd as It, rotationMatrix as J, beginText as Jt, restoreState as K, setMiterLimit as Kt, createMarkedContentScope as L, fillEvenOddAndStroke as Lt, beginArtifact as M, ellipsePath as Mt, beginArtifactWithType as N, endPath as Nt, PdfAnnotation as O, closePath as Ot, beginMarkedContent as P, fill as Pt, skew as Q, nextLine as Qt, endArtifact as R, lineTo as Rt, svgToPdfOperators as S, circlePath as St, parseSvgPath as T, closeAndStroke as Tt, degreesToRadians as U, setLineCap as Ut, concatMatrix as V, setDashPattern as Vt, radians as W, setLineJoin as Wt, scale as X, moveText as Xt, saveState as Y, endText as Yt, setGraphicsState as Z, moveTextSetLeading as Zt, PdfLayer as _, setStrokeColorSpace as _t, renderMultiPageTable as a, setTextRise as an, grayscale as at, endLayerContent as b, drawImageXObject as bt, qrCodeToOperators as c, showTextArray as cn, setFillColor as ct, linearGradient as d, showTextWithSpacing as dn, setFillColorRgb as dt, setFont as en, applyFillColor as et, radialGradient as f, setFillingColor as ft, markForRedaction as g, setStrokeColorRgb as gt, getRedactionMarks as h, setStrokeColorGray as ht, wrapText as i, setTextRenderingMode as in, componentsToColor as it, createAnnotation as j, curveToInitial as jt, annotationFromDict as k, curveTo as kt, buildGradientObjects as l, showTextHex as ln, setFillColorCmyk as lt, applyRedactions as m, setStrokeColorCmyk as mt, PdfPage as n, setLeading as nn, cmyk as nt, renderTable as o, setWordSpacing as on, rgb as ot, tilingPattern as p, setStrokeColor as pt, rotate as q, stroke as qt, pdfPage_exports as r, setTextMatrix as rn, colorToComponents as rt, encodeQrCode as s, showText as sn, setColorSpace as st, PageSizes as t, setFontSize as tn, applyStrokeColor as tt, buildPatternObjects as u, showTextNextLine as un, setFillColorGray as ut, PdfLayerManager as v, setStrokingColor as vt, parseSvgColor as w, clipEvenOdd as wt, drawSvgOnPage as x, drawXObject as xt, beginLayerContent as y, drawImageWithMatrix as yt, endMarkedContent as z, moveTo as zt };
+//# sourceMappingURL=pdfPage-BacMkrLe.mjs.map