pdf-codec 1.3.0 → 1.4.0

package/dist/fonts.d.ts

@@ -0,0 +1,15 @@
+import { r as StandardFontName } from "./afm-widths-DyDq56Ph.js";
+//#region src/fonts.d.ts
+type StandardFamily = 'helvetica' | 'times' | 'courier';
+interface FontFamilyResolution {
+  readonly family: StandardFamily;
+  readonly matched: boolean;
+}
+declare function resolveFontFamily(rawFamily: string): FontFamilyResolution;
+interface ResolvedFont {
+  readonly standardName: StandardFontName;
+  readonly matched: boolean;
+}
+declare function resolveStandardFont(family: string, bold: boolean, italic: boolean): ResolvedFont;
+//#endregion
+export { FontFamilyResolution, ResolvedFont, resolveFontFamily, resolveStandardFont };

package/dist/fonts.js

@@ -0,0 +1,122 @@
+//#region src/fonts.ts
+const FAMILY_BY_NORMALIZED_NAME = /* @__PURE__ */ new Map([
+	["helvetica", "helvetica"],
+	["helveticaneue", "helvetica"],
+	["arial", "helvetica"],
+	["arialnarrow", "helvetica"],
+	["arialblack", "helvetica"],
+	["calibri", "helvetica"],
+	["aptos", "helvetica"],
+	["aptosdisplay", "helvetica"],
+	["segoeui", "helvetica"],
+	["tahoma", "helvetica"],
+	["verdana", "helvetica"],
+	["trebuchetms", "helvetica"],
+	["centurygothic", "helvetica"],
+	["franklingothicbook", "helvetica"],
+	["gillsans", "helvetica"],
+	["futura", "helvetica"],
+	["roboto", "helvetica"],
+	["opensans", "helvetica"],
+	["lato", "helvetica"],
+	["montserrat", "helvetica"],
+	["poppins", "helvetica"],
+	["inter", "helvetica"],
+	["notosans", "helvetica"],
+	["dejavusans", "helvetica"],
+	["sourcesanspro", "helvetica"],
+	["sansserif", "helvetica"],
+	["liberationsans", "helvetica"],
+	["nimbussans", "helvetica"],
+	["times", "times"],
+	["timesnewroman", "times"],
+	["liberationserif", "times"],
+	["nimbusroman", "times"],
+	["georgia", "times"],
+	["cambria", "times"],
+	["constantia", "times"],
+	["garamond", "times"],
+	["bookantiqua", "times"],
+	["palatino", "times"],
+	["palatinolinotype", "times"],
+	["bookmanoldstyle", "times"],
+	["century", "times"],
+	["centuryschoolbook", "times"],
+	["minionpro", "times"],
+	["merriweather", "times"],
+	["notoserif", "times"],
+	["dejavuserif", "times"],
+	["serif", "times"],
+	["courier", "courier"],
+	["couriernew", "courier"],
+	["liberationmono", "courier"],
+	["nimbusmono", "courier"],
+	["consolas", "courier"],
+	["monaco", "courier"],
+	["menlo", "courier"],
+	["lucidaconsole", "courier"],
+	["andalemono", "courier"],
+	["cascadiacode", "courier"],
+	["cascadiamono", "courier"],
+	["sfmono", "courier"],
+	["jetbrainsmono", "courier"],
+	["firacode", "courier"],
+	["sourcecodepro", "courier"],
+	["notosansmono", "courier"],
+	["dejavusansmono", "courier"],
+	["monospace", "courier"]
+]);
+const DEFAULT_FAMILY = "helvetica";
+function normalizeFamilyName(raw) {
+	return raw.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function resolveFontFamily(rawFamily) {
+	const normalized = normalizeFamilyName(rawFamily);
+	const exact = FAMILY_BY_NORMALIZED_NAME.get(normalized);
+	if (exact !== void 0) return {
+		family: exact,
+		matched: true
+	};
+	if (normalized.includes("mono")) return {
+		family: "courier",
+		matched: true
+	};
+	if (normalized.includes("serif") && !normalized.includes("sansserif")) return {
+		family: "times",
+		matched: true
+	};
+	return {
+		family: DEFAULT_FAMILY,
+		matched: false
+	};
+}
+const VARIANTS = {
+	helvetica: {
+		regular: "Helvetica",
+		bold: "Helvetica-Bold",
+		italic: "Helvetica-Oblique",
+		boldItalic: "Helvetica-BoldOblique"
+	},
+	times: {
+		regular: "Times-Roman",
+		bold: "Times-Bold",
+		italic: "Times-Italic",
+		boldItalic: "Times-BoldItalic"
+	},
+	courier: {
+		regular: "Courier",
+		bold: "Courier-Bold",
+		italic: "Courier-Oblique",
+		boldItalic: "Courier-BoldOblique"
+	}
+};
+function resolveStandardFont(family, bold, italic) {
+	const { family: standardFamily, matched } = resolveFontFamily(family);
+	const variants = VARIANTS[standardFamily];
+	return {
+		standardName: bold && italic ? variants.boldItalic : bold ? variants.bold : italic ? variants.italic : variants.regular,
+		matched
+	};
+}
+//#endregion
+export { resolveFontFamily, resolveStandardFont };

package/dist/formula.d.cts

@@ -0,0 +1,10 @@
+import { t as MathBox } from "./math-types-Ba8qAf1p.cjs";
+//#region src/formula.d.ts
+interface PositionedFormula {
+  readonly pageIndex: number;
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly box: MathBox;
+}
+//#endregion
+export { PositionedFormula };

package/dist/formula.d.ts

@@ -0,0 +1,10 @@
+import { t as MathBox } from "./math-types-Ba8qAf1p.js";
+//#region src/formula.d.ts
+interface PositionedFormula {
+  readonly pageIndex: number;
+  readonly xPt: number;
+  readonly yPt: number;
+  readonly box: MathBox;
+}
+//#endregion
+export { PositionedFormula };

package/dist/image/jpeg-info.cjs

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/image/jpeg-info.ts
+const SOI = 216;
+const EOI = 217;
+const APP14 = 238;
+const SOF_MARKERS = /* @__PURE__ */ new Set([
+	192,
+	193,
+	194,
+	201,
+	202
+]);
+const PROGRESSIVE_SOF_MARKERS = /* @__PURE__ */ new Set([194, 202]);
+const NO_PAYLOAD_MARKERS = /* @__PURE__ */ new Set([
+	1,
+	216,
+	217,
+	208,
+	209,
+	210,
+	211,
+	212,
+	213,
+	214,
+	215
+]);
+function requireByte(bytes, index) {
+	const value = bytes[index];
+	if (value === void 0) throw new Error("unexpected end of JPEG data");
+	return value;
+}
+function readUint16BE(bytes, offset) {
+	return requireByte(bytes, offset) << 8 | requireByte(bytes, offset + 1);
+}
+function readJpegInfo(bytes) {
+	if (requireByte(bytes, 0) !== 255 || requireByte(bytes, 1) !== SOI) throw new Error("not a valid JPEG file: missing SOI marker");
+	let offset = 2;
+	let adobeTransform;
+	while (offset < bytes.length) {
+		if (bytes[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		let markerOffset = offset + 1;
+		while (bytes[markerOffset] === 255) markerOffset++;
+		const marker = bytes[markerOffset];
+		if (marker === void 0) break;
+		offset = markerOffset + 1;
+		if (marker === EOI) break;
+		if (NO_PAYLOAD_MARKERS.has(marker)) continue;
+		const segmentLength = readUint16BE(bytes, offset);
+		if (marker === APP14 && segmentLength >= 14) adobeTransform = requireByte(bytes, offset + 2 + 11);
+		if (SOF_MARKERS.has(marker)) {
+			const p = offset + 2;
+			const precision = requireByte(bytes, p);
+			const height = readUint16BE(bytes, p + 1);
+			return {
+				width: readUint16BE(bytes, p + 3),
+				height,
+				components: requireByte(bytes, p + 5),
+				precision,
+				progressive: PROGRESSIVE_SOF_MARKERS.has(marker),
+				adobeTransform
+			};
+		}
+		offset += segmentLength;
+	}
+	throw new Error("no SOF marker found in JPEG file");
+}
+//#endregion
+exports.readJpegInfo = readJpegInfo;

package/dist/image/jpeg-info.d.cts

@@ -0,0 +1,12 @@
+//#region src/image/jpeg-info.d.ts
+interface JpegInfo {
+  readonly width: number;
+  readonly height: number;
+  readonly components: number;
+  readonly precision: number;
+  readonly progressive: boolean;
+  readonly adobeTransform: number | undefined;
+}
+declare function readJpegInfo(bytes: Uint8Array<ArrayBuffer>): JpegInfo;
+//#endregion
+export { JpegInfo, readJpegInfo };

package/dist/image/jpeg-info.d.ts

@@ -0,0 +1,12 @@
+//#region src/image/jpeg-info.d.ts
+interface JpegInfo {
+  readonly width: number;
+  readonly height: number;
+  readonly components: number;
+  readonly precision: number;
+  readonly progressive: boolean;
+  readonly adobeTransform: number | undefined;
+}
+declare function readJpegInfo(bytes: Uint8Array<ArrayBuffer>): JpegInfo;
+//#endregion
+export { JpegInfo, readJpegInfo };

package/dist/image/jpeg-info.js

@@ -0,0 +1,70 @@
+//#region src/image/jpeg-info.ts
+const SOI = 216;
+const EOI = 217;
+const APP14 = 238;
+const SOF_MARKERS = /* @__PURE__ */ new Set([
+	192,
+	193,
+	194,
+	201,
+	202
+]);
+const PROGRESSIVE_SOF_MARKERS = /* @__PURE__ */ new Set([194, 202]);
+const NO_PAYLOAD_MARKERS = /* @__PURE__ */ new Set([
+	1,
+	216,
+	217,
+	208,
+	209,
+	210,
+	211,
+	212,
+	213,
+	214,
+	215
+]);
+function requireByte(bytes, index) {
+	const value = bytes[index];
+	if (value === void 0) throw new Error("unexpected end of JPEG data");
+	return value;
+}
+function readUint16BE(bytes, offset) {
+	return requireByte(bytes, offset) << 8 | requireByte(bytes, offset + 1);
+}
+function readJpegInfo(bytes) {
+	if (requireByte(bytes, 0) !== 255 || requireByte(bytes, 1) !== SOI) throw new Error("not a valid JPEG file: missing SOI marker");
+	let offset = 2;
+	let adobeTransform;
+	while (offset < bytes.length) {
+		if (bytes[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		let markerOffset = offset + 1;
+		while (bytes[markerOffset] === 255) markerOffset++;
+		const marker = bytes[markerOffset];
+		if (marker === void 0) break;
+		offset = markerOffset + 1;
+		if (marker === EOI) break;
+		if (NO_PAYLOAD_MARKERS.has(marker)) continue;
+		const segmentLength = readUint16BE(bytes, offset);
+		if (marker === APP14 && segmentLength >= 14) adobeTransform = requireByte(bytes, offset + 2 + 11);
+		if (SOF_MARKERS.has(marker)) {
+			const p = offset + 2;
+			const precision = requireByte(bytes, p);
+			const height = readUint16BE(bytes, p + 1);
+			return {
+				width: readUint16BE(bytes, p + 3),
+				height,
+				components: requireByte(bytes, p + 5),
+				precision,
+				progressive: PROGRESSIVE_SOF_MARKERS.has(marker),
+				adobeTransform
+			};
+		}
+		offset += segmentLength;
+	}
+	throw new Error("no SOF marker found in JPEG file");
+}
+//#endregion
+export { readJpegInfo };

package/dist/image/png-decode.cjs

@@ -0,0 +1,181 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_bytes_crc32 = require("../bytes/crc32.cjs");
+const require_bytes_writer = require("../bytes/writer.cjs");
+const require_bytes_flate = require("../bytes/flate.cjs");
+const require_image_png_filter = require("./png-filter.cjs");
+//#region src/image/png-decode.ts
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+function requireDataView(bytes) {
+	return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function readChunks(bytes, onWarning) {
+	const chunks = [];
+	const view = requireDataView(bytes);
+	let offset = PNG_SIGNATURE.length;
+	while (offset + 8 <= bytes.length) {
+		const length = view.getUint32(offset);
+		const typeBytes = bytes.subarray(offset + 4, offset + 8);
+		const type = new TextDecoder("latin1").decode(typeBytes);
+		const dataStart = offset + 8;
+		const dataEnd = dataStart + length;
+		if (dataEnd + 4 > bytes.length) throw new Error(`PNG chunk '${type}' declares a length that runs past the end of the file`);
+		const data = bytes.subarray(dataStart, dataEnd);
+		if (onWarning !== void 0) {
+			if (view.getUint32(dataEnd) !== require_bytes_crc32.crc32(require_bytes_writer.concatBytes([typeBytes, data]))) onWarning(`PNG chunk '${type}' failed its CRC32 check`);
+		}
+		chunks.push({
+			type,
+			data
+		});
+		offset = dataEnd + 4;
+		if (type === "IEND") break;
+	}
+	return chunks;
+}
+function parseIhdr(data) {
+	const view = requireDataView(data);
+	return {
+		width: view.getUint32(0),
+		height: view.getUint32(4),
+		bitDepth: data[8],
+		colorType: data[9],
+		interlace: data[12]
+	};
+}
+function channelsForColorType(colorType) {
+	if (colorType === 0) return 1;
+	if (colorType === 2) return 3;
+	if (colorType === 3) return 1;
+	if (colorType === 4) return 2;
+	if (colorType === 6) return 4;
+	throw new Error(`unsupported PNG colour type: ${colorType}`);
+}
+function filterBpp(bitDepth, channels) {
+	return Math.max(1, Math.ceil(bitDepth * channels / 8));
+}
+function unpackRow(rowBytes, width, channels, bitDepth) {
+	const sampleCount = width * channels;
+	const samples = new Array(sampleCount);
+	if (bitDepth === 8) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i];
+	else if (bitDepth === 16) for (let i = 0; i < sampleCount; i++) samples[i] = rowBytes[i * 2];
+	else {
+		const mask = (1 << bitDepth) - 1;
+		for (let i = 0; i < sampleCount; i++) {
+			const bitOffset = i * bitDepth;
+			const byteIndex = bitOffset >> 3;
+			const shift = 8 - bitDepth - (bitOffset & 7);
+			samples[i] = rowBytes[byteIndex] >> shift & mask;
+		}
+	}
+	return samples;
+}
+function readTrnsGrayValue(trns) {
+	return requireDataView(trns).getUint16(0);
+}
+function readTrnsRgbKey(trns) {
+	const view = requireDataView(trns);
+	return [
+		view.getUint16(0),
+		view.getUint16(2),
+		view.getUint16(4)
+	];
+}
+function scaleToByte(sample, bitDepth) {
+	if (bitDepth === 16) return sample;
+	const maxSample = (1 << bitDepth) - 1;
+	return Math.round(sample * 255 / maxSample);
+}
+function decodePng(bytes, options = {}) {
+	for (let i = 0; i < PNG_SIGNATURE.length; i++) if (bytes[i] !== PNG_SIGNATURE[i]) throw new Error("not a valid PNG file: bad signature");
+	const chunks = readChunks(bytes, options.onWarning);
+	const ihdrChunk = chunks[0];
+	if (ihdrChunk?.type !== "IHDR") throw new Error("PNG file does not begin with an IHDR chunk");
+	const ihdr = parseIhdr(ihdrChunk.data);
+	if (ihdr.interlace !== 0) throw new Error("Adam7-interlaced PNG images are not supported");
+	const channels = channelsForColorType(ihdr.colorType);
+	const bpp = filterBpp(ihdr.bitDepth, channels);
+	const bytesPerRow = Math.ceil(ihdr.width * channels * ihdr.bitDepth / 8);
+	const idatChunks = chunks.filter((c) => c.type === "IDAT").map((c) => c.data);
+	if (idatChunks.length === 0) throw new Error("PNG file has no IDAT chunks");
+	const compressed = require_bytes_writer.concatBytes(idatChunks);
+	const { bytes: inflated, recovered } = require_bytes_flate.inflateTolerant(compressed);
+	if (recovered && options.onWarning !== void 0) options.onWarning("PNG IDAT stream required tolerant recovery (truncated or malformed)");
+	const unfiltered = require_image_png_filter.unfilterScanlines(inflated, ihdr.height, bytesPerRow, bpp);
+	const palette = ihdr.colorType === 3 ? chunks.find((c) => c.type === "PLTE")?.data : void 0;
+	if (ihdr.colorType === 3 && palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
+	const trns = chunks.find((c) => c.type === "tRNS")?.data;
+	return buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns);
+}
+function buildRawImage(ihdr, channels, bytesPerRow, unfiltered, palette, trns) {
+	const { width, height, bitDepth, colorType } = ihdr;
+	const outChannels = colorType === 0 || colorType === 4 ? 1 : 3;
+	const data = new Uint8Array(width * height * outChannels);
+	const alpha = colorType === 4 || colorType === 6 || trns !== void 0 ? new Uint8Array(width * height).fill(255) : void 0;
+	const trnsGray = colorType === 0 && trns !== void 0 ? readTrnsGrayValue(trns) : void 0;
+	const trnsRgb = colorType === 2 && trns !== void 0 ? readTrnsRgbKey(trns) : void 0;
+	for (let y = 0; y < height; y++) {
+		const rowStart = y * bytesPerRow;
+		const samples = unpackRow(unfiltered.subarray(rowStart, rowStart + bytesPerRow), width, channels, bitDepth);
+		for (let x = 0; x < width; x++) {
+			const pixelBase = x * channels;
+			const outBase = (y * width + x) * outChannels;
+			const alphaIndex = y * width + x;
+			if (colorType === 0) {
+				const g = samples[pixelBase];
+				data[outBase] = scaleToByte(g, bitDepth);
+				if (alpha !== void 0 && trnsGray !== void 0) alpha[alphaIndex] = g === trnsGray ? 0 : 255;
+			} else if (colorType === 2) {
+				const r = samples[pixelBase];
+				const g = samples[pixelBase + 1];
+				const b = samples[pixelBase + 2];
+				data[outBase] = r;
+				data[outBase + 1] = g;
+				data[outBase + 2] = b;
+				if (alpha !== void 0 && trnsRgb !== void 0) {
+					const [kr, kg, kb] = trnsRgb;
+					alpha[alphaIndex] = r === kr && g === kg && b === kb ? 0 : 255;
+				}
+			} else if (colorType === 3) {
+				const index = samples[pixelBase];
+				if (palette === void 0) throw new Error("indexed-colour PNG has no PLTE chunk");
+				data[outBase] = palette[index * 3];
+				data[outBase + 1] = palette[index * 3 + 1];
+				data[outBase + 2] = palette[index * 3 + 2];
+				if (alpha !== void 0 && trns !== void 0) alpha[alphaIndex] = index < trns.length ? trns[index] : 255;
+			} else if (colorType === 4) {
+				const g = samples[pixelBase];
+				const a = samples[pixelBase + 1];
+				data[outBase] = scaleToByte(g, bitDepth);
+				if (alpha !== void 0) alpha[alphaIndex] = scaleToByte(a, bitDepth);
+			} else {
+				data[outBase] = samples[pixelBase];
+				data[outBase + 1] = samples[pixelBase + 1];
+				data[outBase + 2] = samples[pixelBase + 2];
+				if (alpha !== void 0) alpha[alphaIndex] = samples[pixelBase + 3];
+			}
+		}
+	}
+	return alpha === void 0 ? {
+		width,
+		height,
+		channels: outChannels,
+		data
+	} : {
+		width,
+		height,
+		channels: outChannels,
+		data,
+		alpha
+	};
+}
+//#endregion
+exports.decodePng = decodePng;

package/dist/image/png-decode.d.cts

@@ -0,0 +1,14 @@
+//#region src/image/png-decode.d.ts
+interface RawImage {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: 1 | 3;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly alpha?: Uint8Array<ArrayBuffer>;
+}
+interface PngDecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+declare function decodePng(bytes: Uint8Array<ArrayBuffer>, options?: PngDecodeOptions): RawImage;
+//#endregion
+export { PngDecodeOptions, RawImage, decodePng };

package/dist/image/png-decode.d.ts

@@ -0,0 +1,14 @@
+//#region src/image/png-decode.d.ts
+interface RawImage {
+  readonly width: number;
+  readonly height: number;
+  readonly channels: 1 | 3;
+  readonly data: Uint8Array<ArrayBuffer>;
+  readonly alpha?: Uint8Array<ArrayBuffer>;
+}
+interface PngDecodeOptions {
+  readonly onWarning?: (message: string) => void;
+}
+declare function decodePng(bytes: Uint8Array<ArrayBuffer>, options?: PngDecodeOptions): RawImage;
+//#endregion
+export { PngDecodeOptions, RawImage, decodePng };