modern-pdf-lib 0.15.1 → 0.22.9

package/dist/layout-DgX_0jfK.mjs

@@ -0,0 +1,438 @@
+import { i as wrapText, n as PdfPage, t as PageSizes } from "./pdfPage-Cd8e7flb.mjs";
+
+//#region src/core/enums.ts
+/**
+* PDF blend modes (PDF 1.4+, Table 136).
+* Applied via ExtGState /BM key.
+*/
+const BlendMode = {
+	Normal: "Normal",
+	Multiply: "Multiply",
+	Screen: "Screen",
+	Overlay: "Overlay",
+	Darken: "Darken",
+	Lighten: "Lighten",
+	ColorDodge: "ColorDodge",
+	ColorBurn: "ColorBurn",
+	HardLight: "HardLight",
+	SoftLight: "SoftLight",
+	Difference: "Difference",
+	Exclusion: "Exclusion"
+};
+/**
+* PDF text rendering modes (Table 106).
+* Applied via the Tr operator inside a text object.
+*/
+const TextRenderingMode = {
+	Fill: 0,
+	Outline: 1,
+	FillAndOutline: 2,
+	Invisible: 3,
+	FillAndClip: 4,
+	OutlineAndClip: 5,
+	FillAndOutlineAndClip: 6,
+	Clip: 7
+};
+/**
+* PDF line cap styles (Table 54).
+* Applied via the J operator.
+*/
+const LineCapStyle = {
+	Butt: 0,
+	Round: 1,
+	Projecting: 2
+};
+/**
+* PDF line join styles (Table 55).
+* Applied via the j operator.
+*/
+const LineJoinStyle = {
+	Miter: 0,
+	Round: 1,
+	Bevel: 2
+};
+/**
+* Text alignment for form fields and layout operations.
+*/
+const TextAlignment = {
+	Left: 0,
+	Center: 1,
+	Right: 2
+};
+/**
+* Image alignment for layout operations.
+*/
+const ImageAlignment = {
+	Left: 0,
+	Center: 1,
+	Right: 2
+};
+/**
+* Preset parsing speeds — maps to objectsPerTick values in LoadPdfOptions.
+*
+* Lower values keep the main thread more responsive but parse more slowly.
+*/
+const ParseSpeeds = {
+	Fastest: Infinity,
+	Fast: 500,
+	Medium: 100,
+	Slow: 10
+};
+
+//#endregion
+//#region src/core/pageManipulation.ts
+/**
+* Resolve a PageSize input to a `[width, height]` tuple.
+*
+* @param size  Page size as a tuple, object, or undefined (defaults to A4).
+* @returns     A `[width, height]` tuple in PDF points.
+*/
+function resolveSize(size) {
+	const resolved = size ?? PageSizes.A4;
+	if (Array.isArray(resolved)) return [resolved[0], resolved[1]];
+	return [resolved.width, resolved.height];
+}
+/**
+* Validate that a page index is within bounds.
+*
+* @param index      The index to validate.
+* @param pageCount  The total number of pages.
+* @param operation  A description of the operation for error messages.
+* @throws RangeError if the index is out of bounds.
+*/
+function validateIndex(index, pageCount, operation) {
+	if (!Number.isInteger(index) || index < 0 || index >= pageCount) throw new RangeError(`${operation}: index ${index} out of range [0, ${pageCount - 1}]`);
+}
+/**
+* Validate that a page index is valid for insertion (0 to pageCount inclusive).
+*
+* @param index      The index to validate.
+* @param pageCount  The total number of pages.
+* @param operation  A description of the operation for error messages.
+* @throws RangeError if the index is out of bounds.
+*/
+function validateInsertIndex(index, pageCount, operation) {
+	if (!Number.isInteger(index) || index < 0 || index > pageCount) throw new RangeError(`${operation}: index ${index} out of range [0, ${pageCount}]`);
+}
+/**
+* Validate that a rotation angle is a multiple of 90.
+*
+* @param angle  The rotation angle in degrees.
+* @throws Error if the angle is not a valid rotation.
+*/
+function validateRotation(angle) {
+	if (angle % 90 !== 0) throw new Error(`rotatePage: angle must be a multiple of 90, got ${angle}`);
+}
+/**
+* Insert a new blank page into the document at the specified position.
+*
+* All existing pages at `index` and beyond are shifted to make room.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based position at which to insert the page.
+*               Must be in the range `[0, pageCount]`.
+* @param size   Optional page size. Defaults to A4.
+* @returns      The newly created PdfPage.
+*
+* @example
+* ```ts
+* import { createPdf, insertPage, PageSizes } from 'modern-pdf-lib';
+*
+* const doc = createPdf();
+* doc.addPage();
+* const newPage = insertPage(doc, 0, PageSizes.Letter); // insert at front
+* ```
+*/
+function insertPage(doc, index, size) {
+	const pages = doc.getInternalPages();
+	const registry = doc.getRegistry();
+	validateInsertIndex(index, pages.length, "insertPage");
+	const [w, h] = resolveSize(size);
+	const page = new PdfPage(w, h, registry);
+	doc.registerFontsOnPage(page);
+	pages.splice(index, 0, page);
+	return page;
+}
+/**
+* Remove a page from the document by its zero-based index.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based index of the page to remove.
+* @throws       RangeError if the index is out of bounds.
+*
+* @example
+* ```ts
+* removePage(doc, 0); // Remove the first page
+* ```
+*/
+function removePage(doc, index) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "removePage");
+	pages.splice(index, 1);
+}
+/**
+* Move a page from one position to another within the document.
+*
+* The page at `fromIndex` is removed and then inserted at `toIndex`
+* (computed after the removal).
+*
+* @param doc        The PdfDocument to modify.
+* @param fromIndex  Current zero-based index of the page to move.
+* @param toIndex    Target zero-based index. Must be in range
+*                   `[0, pageCount - 1]` after removal.
+* @throws           RangeError if either index is out of bounds.
+*
+* @example
+* ```ts
+* movePage(doc, 2, 0); // Move page 2 to the front
+* ```
+*/
+function movePage(doc, fromIndex, toIndex) {
+	const pages = doc.getInternalPages();
+	validateIndex(fromIndex, pages.length, "movePage (fromIndex)");
+	const [page] = pages.splice(fromIndex, 1);
+	if (toIndex < 0 || toIndex > pages.length) {
+		pages.splice(fromIndex, 0, page);
+		throw new RangeError(`movePage (toIndex): index ${toIndex} out of range [0, ${pages.length}]`);
+	}
+	pages.splice(toIndex, 0, page);
+}
+/**
+* Rotate a page by the specified angle.
+*
+* The angle is cumulative with any existing rotation set on the page.
+* The page's `/Rotate` entry in the page dictionary will be set when
+* the document is saved.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based index of the page to rotate.
+* @param angle  Rotation angle in degrees. Must be a multiple of 90.
+*               Common values: 90, 180, 270, -90.
+* @throws       RangeError if the index is out of bounds.
+* @throws       Error if the angle is not a multiple of 90.
+*
+* @example
+* ```ts
+* rotatePage(doc, 0, 90); // Rotate first page 90 degrees clockwise
+* ```
+*/
+function rotatePage(doc, index, angle) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "rotatePage");
+	validateRotation(angle);
+	const page = pages[index];
+	const newRotation = (((page.getRotation?.() ?? 0) + angle) % 360 + 360) % 360;
+	page.setRotation(newRotation);
+}
+/**
+* Set a crop box on a page.
+*
+* The crop box defines the visible region of the page when displayed
+* or printed. It defaults to the media box if not set.
+*
+* @param doc      The PdfDocument to modify.
+* @param index    Zero-based index of the page.
+* @param cropBox  The crop box rectangle.
+* @throws         RangeError if the index is out of bounds.
+*
+* @example
+* ```ts
+* cropPage(doc, 0, { x: 50, y: 50, width: 495, height: 742 });
+* ```
+*/
+function cropPage(doc, index, cropBox) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "cropPage");
+	pages[index].setCropBox(cropBox.x, cropBox.y, cropBox.width, cropBox.height);
+}
+/**
+* Get the size of a page.
+*
+* @param doc    The PdfDocument.
+* @param index  Zero-based page index.
+* @returns      A `{ width, height }` object in PDF points.
+*/
+function getPageSize(doc, index) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "getPageSize");
+	const page = pages[index];
+	return {
+		width: page.width,
+		height: page.height
+	};
+}
+/**
+* Resize a page by setting its media box.
+*
+* Note: This changes the page dimensions but does not scale existing
+* content. Content that was drawn at coordinates beyond the new
+* dimensions may be clipped.
+*
+* @param doc    The PdfDocument to modify.
+* @param index  Zero-based page index.
+* @param size   New page size.
+*/
+function resizePage(doc, index, size) {
+	const pages = doc.getInternalPages();
+	validateIndex(index, pages.length, "resizePage");
+	const [w, h] = resolveSize(size);
+	pages[index].setMediaBox(0, 0, w, h);
+}
+/**
+* Reverse the page order of the entire document.
+*
+* @param doc  The PdfDocument to modify.
+*/
+function reversePages(doc) {
+	doc.getInternalPages().reverse();
+}
+/**
+* Remove multiple pages at once, given their zero-based indices.
+*
+* Indices are processed in descending order to avoid shifting issues.
+*
+* @param doc      The PdfDocument to modify.
+* @param indices  Array of zero-based page indices to remove.
+* @throws         RangeError if any index is out of bounds.
+*/
+function removePages(doc, indices) {
+	const pages = doc.getInternalPages();
+	for (const index of indices) validateIndex(index, pages.length, "removePages");
+	const sorted = new Set(indices).values().toArray().sort((a, b) => b - a);
+	for (const index of sorted) pages.splice(index, 1);
+}
+/**
+* Rotate all pages in the document by the specified angle.
+*
+* @param doc    The PdfDocument to modify.
+* @param angle  Rotation angle in degrees (must be a multiple of 90).
+*/
+function rotateAllPages(doc, angle) {
+	validateRotation(angle);
+	const pages = doc.getInternalPages();
+	for (const page of pages) {
+		const newRotation = (((page.getRotation?.() ?? 0) + angle) % 360 + 360) % 360;
+		page.setRotation(newRotation);
+	}
+}
+
+//#endregion
+//#region src/core/layout.ts
+/**
+* Break text into lines that fit within `maxWidth`, measuring each line's
+* width.  Explicit newlines (`\n`) are always honoured.
+*
+* The returned `height` is the total vertical extent: one line's ascent
+* plus `(n-1) * lineHeight`.
+*/
+function layoutMultilineText(text, options) {
+	const { font, fontSize, maxWidth, wordBreaks } = options;
+	const lineHeight = options.lineHeight ?? fontSize * 1.2;
+	const rawLines = text.split("\n");
+	const allLines = [];
+	for (const rawLine of rawLines) if (maxWidth > 0) {
+		const wrapped = wrapText(rawLine, maxWidth, font, fontSize, wordBreaks);
+		for (const line of wrapped) allLines.push({
+			text: line,
+			width: font.widthOfTextAtSize(line, fontSize)
+		});
+	} else allLines.push({
+		text: rawLine,
+		width: font.widthOfTextAtSize(rawLine, fontSize)
+	});
+	return {
+		lines: allLines,
+		height: allLines.length > 0 ? font.heightAtSize(fontSize) + (allLines.length - 1) * lineHeight : 0
+	};
+}
+/**
+* Layout text into evenly-spaced cells for combed text fields.
+*
+* Each character is centred within its cell.  Characters beyond
+* `cellCount` are silently truncated.
+*/
+function layoutCombedText(text, options) {
+	const { font, fontSize, cellCount, cellWidth } = options;
+	return text.slice(0, cellCount).split("").map((char, i) => {
+		const charWidth = font.widthOfTextAtSize(char, fontSize);
+		return {
+			char,
+			x: i * cellWidth + cellWidth / 2 - charWidth / 2,
+			width: charWidth
+		};
+	});
+}
+/**
+* Compute the largest font size (in points) at which `text` fits within
+* the given width (and optionally height) constraints.
+*
+* Uses binary search between `minSize` (default 4) and `maxSize`
+* (default 500), converging to within 0.1 pt.
+*/
+function computeFontSize(text, options) {
+	const { font, maxWidth, wordBreaks } = options;
+	const maxHeight = options.maxHeight ?? Infinity;
+	const minSize = options.minSize ?? 4;
+	const maxSize = options.maxSize ?? 500;
+	let lo = minSize;
+	let hi = maxSize;
+	for (let i = 0; i < 40; i++) {
+		const mid = (lo + hi) / 2;
+		const layout = layoutMultilineText(text, {
+			font,
+			fontSize: mid,
+			maxWidth,
+			lineHeight: options.lineHeight,
+			wordBreaks
+		});
+		if (layout.height <= maxHeight && layout.lines.every((line) => line.width <= maxWidth)) lo = mid;
+		else hi = mid;
+		if (hi - lo < .1) break;
+	}
+	return Math.floor(lo * 10) / 10;
+}
+/**
+* Layout a single line of text with optional alignment within bounds.
+*
+* Unlike {@link layoutMultilineText}, this does not perform any wrapping.
+* It simply measures the text, computes alignment offsets, and returns
+* the positioned line.
+*
+* @param text     The text to lay out (single line, no newlines).
+* @param options  Font, size, bounds, alignment.
+* @returns        The measured line and its position offsets.
+*/
+function layoutSinglelineText(text, options) {
+	const { font, fontSize, bounds, alignment } = options;
+	const width = font.widthOfTextAtSize(text, fontSize);
+	const height = font.heightAtSize(fontSize);
+	let x = 0;
+	let y = 0;
+	if (bounds) {
+		y = (bounds.height - height) / 2;
+		switch (alignment) {
+			case 1:
+				x = (bounds.width - width) / 2;
+				break;
+			case 2:
+				x = bounds.width - width;
+				break;
+			default:
+				x = 0;
+				break;
+		}
+	}
+	return {
+		line: {
+			text,
+			width,
+			height
+		},
+		x,
+		y
+	};
+}
+
+//#endregion
+export { LineCapStyle as _, cropPage as a, TextAlignment as b, movePage as c, resizePage as d, reversePages as f, ImageAlignment as g, BlendMode as h, layoutSinglelineText as i, removePage as l, rotatePage as m, layoutCombedText as n, getPageSize as o, rotateAllPages as p, layoutMultilineText as r, insertPage as s, computeFontSize as t, removePages as u, LineJoinStyle as v, TextRenderingMode as x, ParseSpeeds as y };
+//# sourceMappingURL=layout-DgX_0jfK.mjs.map

package/dist/{libdeflateWasm-Cg7cWHOq.cjs → libdeflateWasm-BdiDEJOj.cjs}

@@ -75,7 +75,7 @@ async function initDeflateWasm(wasmBytes) {
 		let bytes;
 		if (wasmBytes) bytes = wasmBytes;
 		else {
-			const { loadWasmModule } = await Promise.resolve().then(() => require("./loader-DdB5Xo5D.cjs"));
+			const { loadWasmModule } = await Promise.resolve().then(() => require("./loader-I4zdkoWc.cjs")).then((n) => n.loader_exports);
 			bytes = await loadWasmModule("libdeflate");
 		}
 		const compiled = await WebAssembly.compile(new Uint8Array(bytes));
@@ -234,4 +234,4 @@ Object.defineProperty(exports, 'libdeflateWasm_exports', {
     return libdeflateWasm_exports;
   }
 });
-//# sourceMappingURL=libdeflateWasm-Cg7cWHOq.cjs.map
+//# sourceMappingURL=libdeflateWasm-BdiDEJOj.cjs.map

package/dist/{libdeflateWasm-Cmxa-yiS.mjs → libdeflateWasm-rLppXytE.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { Ka as __exportAll } from "./index-BtYOx5wh.d.mts";
 
 //#region src/compression/libdeflateWasm.ts
 var libdeflateWasm_exports = /* @__PURE__ */ __exportAll({
@@ -75,7 +75,7 @@ async function initDeflateWasm(wasmBytes) {
 		let bytes;
 		if (wasmBytes) bytes = wasmBytes;
 		else {
-			const { loadWasmModule } = await import("./loader-B6VIrZOJ.mjs");
+			const { loadWasmModule } = await import("./loader-3u6Tw5T-.mjs").then((n) => n.l);
 			bytes = await loadWasmModule("libdeflate");
 		}
 		const compiled = await WebAssembly.compile(new Uint8Array(bytes));
@@ -217,4 +217,4 @@ var LibdeflateWasm = class {
 
 //#endregion
 export { isAvailable as n, libdeflateWasm_exports as r, deflateSync as t };
-//# sourceMappingURL=libdeflateWasm-Cmxa-yiS.mjs.map
+//# sourceMappingURL=libdeflateWasm-rLppXytE.mjs.map