reamkit 1.5.0 → 1.7.0

package/dist/esm/pdf-reader/content.js

@@ -0,0 +1,420 @@
+import { PDF_NULL, PdfHexString, PdfName } from "../pdf/objects.js";
+import { Lexer } from "./lexer.js";
+//#region src/pdf-reader/content.ts
+var IDENTITY = [
+	1,
+	0,
+	0,
+	1,
+	0,
+	0
+];
+function multiply(a, b) {
+	return [
+		a[0] * b[0] + a[1] * b[2],
+		a[0] * b[1] + a[1] * b[3],
+		a[2] * b[0] + a[3] * b[2],
+		a[2] * b[1] + a[3] * b[3],
+		a[4] * b[0] + a[5] * b[2] + b[4],
+		a[4] * b[1] + a[5] * b[3] + b[5]
+	];
+}
+function translation(tx, ty) {
+	return [
+		1,
+		0,
+		0,
+		1,
+		tx,
+		ty
+	];
+}
+var FALLBACK_FONT = {
+	bytesPerCode: 1,
+	decode: (codes) => codes.map((c) => String.fromCharCode(c)).join(""),
+	width: () => 500
+};
+function initialState() {
+	return {
+		ctm: IDENTITY,
+		fontKey: "",
+		font: FALLBACK_FONT,
+		fontSize: 0,
+		charSpacing: 0,
+		wordSpacing: 0,
+		hScale: 1,
+		leading: 0,
+		rise: 0,
+		fillColor: "000000"
+	};
+}
+function interpretContent(bytes, fonts, initialCtm = IDENTITY) {
+	const runs = [];
+	const images = [];
+	const vectors = [];
+	const lexer = new Lexer(bytes);
+	const stack = [];
+	let state = initialState();
+	state.ctm = initialCtm;
+	let tm = IDENTITY;
+	let tlm = IDENTITY;
+	let path = [];
+	let operands = [];
+	const mcStack = [];
+	const toPage = (x, y) => [x * state.ctm[0] + y * state.ctm[2] + state.ctm[4], x * state.ctm[1] + y * state.ctm[3] + state.ctm[5]];
+	const moveTo = (x, y) => {
+		const [px, py] = toPage(x, y);
+		path.push({
+			op: "move",
+			x: px,
+			y: py
+		});
+	};
+	const lineTo = (x, y) => {
+		const [px, py] = toPage(x, y);
+		path.push({
+			op: "line",
+			x: px,
+			y: py
+		});
+	};
+	const curveTo = (a, b, c, d, e, f) => {
+		const [x1, y1] = toPage(a, b);
+		const [x2, y2] = toPage(c, d);
+		const [x, y] = toPage(e, f);
+		path.push({
+			op: "cubic",
+			x1,
+			y1,
+			x2,
+			y2,
+			x,
+			y
+		});
+	};
+	const rectTo = (x, y, w, h) => {
+		moveTo(x, y);
+		lineTo(x + w, y);
+		lineTo(x + w, y + h);
+		lineTo(x, y + h);
+		path.push({ op: "close" });
+	};
+	const fillPath = () => {
+		if (path.length >= 2) {
+			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
+			vectors.push({
+				segs: path,
+				fillHex: state.fillColor,
+				...mcid !== void 0 ? { mcid } : {}
+			});
+		}
+		path = [];
+	};
+	const num = (i) => {
+		const v = operands[i];
+		return typeof v === "number" ? v : 0;
+	};
+	const advanceGlyph = (code) => {
+		const w0 = state.font.width(code) / 1e3;
+		const isSpace = state.font.bytesPerCode === 1 && code === 32;
+		tm = multiply(translation((w0 * state.fontSize + state.charSpacing + (isSpace ? state.wordSpacing : 0)) * state.hScale, 0), tm);
+	};
+	const consume = (operand) => {
+		const codes = splitCodes(toBytes(operand), state.font.bytesPerCode);
+		for (const code of codes) advanceGlyph(code);
+		return state.font.decode(codes);
+	};
+	const emitAt = (origin, text) => {
+		if (text.length === 0) return;
+		const scaleY = Math.hypot(origin[2], origin[3]) || 1;
+		const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
+		runs.push({
+			text,
+			x: origin[4],
+			y: origin[5],
+			fontSizePt: state.fontSize * scaleY,
+			fontKey: state.fontKey,
+			...mcid !== void 0 ? { mcid } : {}
+		});
+	};
+	const showString = (operand) => {
+		emitAt(multiply(tm, state.ctm), consume(operand));
+	};
+	const showArray = (arr) => {
+		const origin = multiply(tm, state.ctm);
+		let text = "";
+		for (const el of arr) if (typeof el === "number") tm = multiply(translation(-el / 1e3 * state.fontSize * state.hScale, 0), tm);
+		else if (typeof el === "string" || el instanceof PdfHexString) text += consume(el);
+		emitAt(origin, text);
+	};
+	const exec = (op) => {
+		switch (op) {
+			case "q":
+				stack.push({ ...state });
+				break;
+			case "Q":
+				state = stack.pop() ?? state;
+				break;
+			case "cm":
+				state.ctm = multiply(matrixFromOperands(operands), state.ctm);
+				break;
+			case "BT":
+				tm = IDENTITY;
+				tlm = IDENTITY;
+				break;
+			case "ET": break;
+			case "Tf": {
+				const key = operands[0] instanceof PdfName ? operands[0].value : "";
+				state.fontKey = key;
+				state.font = fonts.get(key) ?? FALLBACK_FONT;
+				state.fontSize = num(1);
+				break;
+			}
+			case "Td":
+				tlm = multiply(translation(num(0), num(1)), tlm);
+				tm = tlm;
+				break;
+			case "TD":
+				state.leading = -num(1);
+				tlm = multiply(translation(num(0), num(1)), tlm);
+				tm = tlm;
+				break;
+			case "Tm":
+				tlm = matrixFromOperands(operands);
+				tm = tlm;
+				break;
+			case "T*":
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				break;
+			case "TL":
+				state.leading = num(0);
+				break;
+			case "Tc":
+				state.charSpacing = num(0);
+				break;
+			case "Tw":
+				state.wordSpacing = num(0);
+				break;
+			case "Tz":
+				state.hScale = num(0) / 100;
+				break;
+			case "Ts":
+				state.rise = num(0);
+				break;
+			case "Tj":
+				if (operands.length > 0) showString(operands[operands.length - 1]);
+				break;
+			case "TJ":
+				if (Array.isArray(operands[0])) showArray(operands[0]);
+				break;
+			case "'":
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				if (operands.length > 0) showString(operands[operands.length - 1]);
+				break;
+			case "\"":
+				state.wordSpacing = num(0);
+				state.charSpacing = num(1);
+				tlm = multiply(translation(0, -state.leading), tlm);
+				tm = tlm;
+				if (operands.length > 2) showString(operands[2]);
+				break;
+			case "BDC": {
+				const tag = operands[operands.length - 2];
+				const props = operands[operands.length - 1];
+				const mcidVal = !(tag instanceof PdfName && tag.value === "Artifact") && props instanceof Map ? props.get("MCID") : void 0;
+				mcStack.push(typeof mcidVal === "number" ? mcidVal : void 0);
+				break;
+			}
+			case "BMC":
+				mcStack.push(void 0);
+				break;
+			case "EMC":
+				mcStack.pop();
+				break;
+			case "Do": {
+				const nm = operands[0];
+				if (nm instanceof PdfName) {
+					const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
+					images.push({
+						name: nm.value,
+						ctm: state.ctm,
+						...mcid !== void 0 ? { mcid } : {}
+					});
+				}
+				break;
+			}
+			case "rg":
+				state.fillColor = rgbHex(num(0), num(1), num(2));
+				break;
+			case "g":
+				state.fillColor = grayHex(num(0));
+				break;
+			case "k":
+				state.fillColor = cmykHex(num(0), num(1), num(2), num(3));
+				break;
+			case "m":
+				moveTo(num(0), num(1));
+				break;
+			case "l":
+				lineTo(num(0), num(1));
+				break;
+			case "c":
+				curveTo(num(0), num(1), num(2), num(3), num(4), num(5));
+				break;
+			case "re":
+				rectTo(num(0), num(1), num(2), num(3));
+				break;
+			case "h":
+				path.push({ op: "close" });
+				break;
+			case "f":
+			case "F":
+			case "f*":
+			case "B":
+			case "B*":
+				fillPath();
+				break;
+			case "b":
+			case "b*":
+				path.push({ op: "close" });
+				fillPath();
+				break;
+			case "n":
+			case "S":
+			case "s":
+			case "W":
+			case "W*":
+				path = [];
+				break;
+			default: break;
+		}
+	};
+	for (;;) {
+		lexer.skipWhitespace();
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") break;
+		switch (tok.kind) {
+			case "num":
+				operands.push(tok.value);
+				break;
+			case "name":
+				operands.push(new PdfName(tok.value));
+				break;
+			case "str":
+				operands.push(tok.value);
+				break;
+			case "hexstr":
+				operands.push(new PdfHexString(tok.bytes));
+				break;
+			case "arrayOpen":
+				operands.push(readArray(lexer));
+				break;
+			case "dictOpen":
+				operands.push(readDict(lexer));
+				break;
+			case "keyword":
+				if (tok.value === "BI") skipInlineImage(lexer);
+				else exec(tok.value);
+				operands = [];
+				break;
+			default:
+				operands = [];
+				break;
+		}
+	}
+	return {
+		texts: runs,
+		images,
+		vectors
+	};
+}
+function clamp255(v) {
+	return Math.max(0, Math.min(255, Math.round(v * 255)));
+}
+function hex2(v) {
+	return clamp255(v).toString(16).padStart(2, "0");
+}
+function rgbHex(r, g, b) {
+	return (hex2(r) + hex2(g) + hex2(b)).toUpperCase();
+}
+function grayHex(v) {
+	return rgbHex(v, v, v);
+}
+function cmykHex(c, m, y, k) {
+	return rgbHex((1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k));
+}
+function matrixFromOperands(operands) {
+	const n = (i) => typeof operands[i] === "number" ? operands[i] : 0;
+	return [
+		n(0),
+		n(1),
+		n(2),
+		n(3),
+		n(4),
+		n(5)
+	];
+}
+function toBytes(operand) {
+	if (operand instanceof PdfHexString) return operand.bytes;
+	if (typeof operand === "string") {
+		const out = new Uint8Array(operand.length);
+		for (let i = 0; i < operand.length; i++) out[i] = operand.charCodeAt(i) & 255;
+		return out;
+	}
+	return new Uint8Array(0);
+}
+function splitCodes(bytes, bytesPerCode) {
+	const out = [];
+	if (bytesPerCode === 2) {
+		for (let i = 0; i + 1 < bytes.length; i += 2) out.push(bytes[i] << 8 | bytes[i + 1]);
+		if (bytes.length % 2 === 1) out.push(bytes[bytes.length - 1]);
+	} else for (const b of bytes) out.push(b);
+	return out;
+}
+function readArray(lexer) {
+	const out = [];
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "arrayClose" || tok.kind === "eof") break;
+		if (tok.kind === "num") out.push(tok.value);
+		else if (tok.kind === "str") out.push(tok.value);
+		else if (tok.kind === "hexstr") out.push(new PdfHexString(tok.bytes));
+	}
+	return out;
+}
+function readDict(lexer) {
+	const map = /* @__PURE__ */ new Map();
+	for (;;) {
+		const key = lexer.nextToken();
+		if (key.kind === "dictClose" || key.kind === "eof") break;
+		if (key.kind !== "name") continue;
+		map.set(key.value, readValue(lexer));
+	}
+	return map;
+}
+function readValue(lexer) {
+	const tok = lexer.nextToken();
+	switch (tok.kind) {
+		case "num": return tok.value;
+		case "name": return new PdfName(tok.value);
+		case "str": return tok.value;
+		case "hexstr": return new PdfHexString(tok.bytes);
+		case "arrayOpen": return readArray(lexer);
+		case "dictOpen": return readDict(lexer);
+		case "keyword": return tok.value === "true" ? true : tok.value === "false" ? false : PDF_NULL;
+		default: return PDF_NULL;
+	}
+}
+function skipInlineImage(lexer) {
+	for (;;) {
+		const tok = lexer.nextToken();
+		if (tok.kind === "eof") return;
+		if (tok.kind === "keyword" && tok.value === "ID") break;
+	}
+	const ei = lexer.indexOfAscii("EI", lexer.pos);
+	lexer.pos = ei < 0 ? lexer.length : ei + 2;
+}
+//#endregion
+export { interpretContent, multiply };

package/dist/esm/pdf-reader/crypto.d.ts

@@ -0,0 +1,7 @@
+export declare function rc4(key: Uint8Array, data: Uint8Array): Uint8Array;
+export declare function md5(input: Uint8Array): Uint8Array;
+export declare function sha256(input: Uint8Array): Uint8Array;
+export declare function sha512(input: Uint8Array): Uint8Array;
+export declare function sha384(input: Uint8Array): Uint8Array;
+export declare function aesCbcDecrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array, stripPad: boolean): Uint8Array;
+export declare function aesCbcEncrypt(key: Uint8Array, iv: Uint8Array, data: Uint8Array): Uint8Array;