reamkit 1.7.0 → 1.10.0

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

@@ -0,0 +1,394 @@
+//#region src/pdf-reader/ccitt.ts
+function decodeCcitt(data, params) {
+	const { k, columns, rows, byteAlign } = params;
+	if (k > 0) return void 0;
+	if (columns <= 0 || rows <= 0 || columns > 1 << 20) return void 0;
+	const reader = new BitReader(data);
+	const rowBytes = columns + 7 >> 3;
+	const out = new Uint8Array(rowBytes * rows);
+	let ref = [columns, columns];
+	for (let y = 0; y < rows; y++) {
+		if (byteAlign && y > 0) reader.align();
+		const cur = k < 0 ? decode2D(reader, ref, columns) : decode1D(reader, columns);
+		if (!cur) {
+			if (y === 0) return void 0;
+			break;
+		}
+		expandRow(cur, columns, out, y * rowBytes);
+		cur.push(columns, columns);
+		ref = cur;
+	}
+	return out;
+}
+function decode1D(reader, columns) {
+	const cur = [];
+	let pos = 0;
+	let color = 0;
+	while (pos < columns) {
+		const run = readRun(reader, color);
+		if (run < 0) return cur.length > 0 ? cur : null;
+		pos = Math.min(pos + run, columns);
+		cur.push(pos);
+		color ^= 1;
+	}
+	return cur;
+}
+function decode2D(reader, ref, columns) {
+	const cur = [];
+	let a0 = -1;
+	let color = 0;
+	while (a0 < columns) {
+		const [b1, b2] = findB(ref, a0, color, columns);
+		const mode = readMode(reader);
+		if (!mode) return cur.length > 0 || a0 >= 0 ? cur : null;
+		if (mode.kind === "pass") a0 = b2;
+		else if (mode.kind === "horizontal") {
+			const start = a0 < 0 ? 0 : a0;
+			const r1 = readRun(reader, color);
+			const r2 = readRun(reader, color ^ 1);
+			if (r1 < 0 || r2 < 0) return cur.length > 0 ? cur : null;
+			const a1 = Math.min(start + r1, columns);
+			const a2 = Math.min(a1 + r2, columns);
+			cur.push(a1, a2);
+			a0 = a2;
+		} else {
+			const a1 = Math.min(Math.max(b1 + mode.d, 0), columns);
+			cur.push(a1);
+			a0 = a1;
+			color ^= 1;
+		}
+	}
+	return cur;
+}
+function findB(ref, a0, color, columns) {
+	let i = 0;
+	while (i < ref.length && ref[i] <= a0) i++;
+	const wantEven = color === 0;
+	if (i < ref.length && i % 2 === 0 !== wantEven) i++;
+	return [i < ref.length ? ref[i] : columns, i + 1 < ref.length ? ref[i + 1] : columns];
+}
+function expandRow(cur, columns, out, rowOff) {
+	let prev = 0;
+	let color = 0;
+	for (const cRaw of cur) {
+		const c = Math.min(cRaw, columns);
+		if (color === 1) setBlack(out, rowOff, prev, c);
+		prev = c;
+		color ^= 1;
+		if (prev >= columns) return;
+	}
+	if (color === 1 && prev < columns) setBlack(out, rowOff, prev, columns);
+}
+function setBlack(out, rowOff, from, to) {
+	for (let x = from; x < to; x++) out[rowOff + (x >> 3)] |= 128 >> (x & 7);
+}
+function readRun(reader, color) {
+	const table = color === 1 ? BLACK : WHITE;
+	let total = 0;
+	for (let guard = 0; guard < 64; guard++) {
+		const run = readCode(reader, table);
+		if (run < 0) return -1;
+		total += run;
+		if (run < 64) return total;
+	}
+	return -1;
+}
+function readMode(reader) {
+	let code = 0;
+	for (let len = 1; len <= 7; len++) {
+		const b = reader.readBit();
+		if (b < 0) return void 0;
+		code = code << 1 | b;
+		const m = MODES.get(len << 8 | code);
+		if (m) return m;
+	}
+}
+function readCode(reader, table) {
+	let code = 0;
+	for (let len = 1; len <= table.maxLen; len++) {
+		const b = reader.readBit();
+		if (b < 0) return -1;
+		code = code << 1 | b;
+		const run = table.map.get(len << 16 | code);
+		if (run !== void 0) return run;
+	}
+	return -1;
+}
+var BitReader = class {
+	bytePos = 0;
+	bitPos = 0;
+	constructor(data) {
+		this.data = data;
+	}
+	readBit() {
+		if (this.bytePos >= this.data.length) return -1;
+		const bit = this.data[this.bytePos] >> 7 - this.bitPos & 1;
+		if (++this.bitPos === 8) {
+			this.bitPos = 0;
+			this.bytePos++;
+		}
+		return bit;
+	}
+	align() {
+		if (this.bitPos !== 0) {
+			this.bitPos = 0;
+			this.bytePos++;
+		}
+	}
+};
+var WHITE_CODES = [
+	[0, "00110101"],
+	[1, "000111"],
+	[2, "0111"],
+	[3, "1000"],
+	[4, "1011"],
+	[5, "1100"],
+	[6, "1110"],
+	[7, "1111"],
+	[8, "10011"],
+	[9, "10100"],
+	[10, "00111"],
+	[11, "01000"],
+	[12, "001000"],
+	[13, "000011"],
+	[14, "110100"],
+	[15, "110101"],
+	[16, "101010"],
+	[17, "101011"],
+	[18, "0100111"],
+	[19, "0001100"],
+	[20, "0001000"],
+	[21, "0010111"],
+	[22, "0000011"],
+	[23, "0000100"],
+	[24, "0101000"],
+	[25, "0101011"],
+	[26, "0010011"],
+	[27, "0100100"],
+	[28, "0011000"],
+	[29, "00000010"],
+	[30, "00000011"],
+	[31, "00011010"],
+	[32, "00011011"],
+	[33, "00010010"],
+	[34, "00010011"],
+	[35, "00010100"],
+	[36, "00010101"],
+	[37, "00010110"],
+	[38, "00010111"],
+	[39, "00101000"],
+	[40, "00101001"],
+	[41, "00101010"],
+	[42, "00101011"],
+	[43, "00101100"],
+	[44, "00101101"],
+	[45, "00000100"],
+	[46, "00000101"],
+	[47, "00001010"],
+	[48, "00001011"],
+	[49, "01010010"],
+	[50, "01010011"],
+	[51, "01010100"],
+	[52, "01010101"],
+	[53, "00100100"],
+	[54, "00100101"],
+	[55, "01011000"],
+	[56, "01011001"],
+	[57, "01011010"],
+	[58, "01011011"],
+	[59, "01001010"],
+	[60, "01001011"],
+	[61, "00110010"],
+	[62, "00110011"],
+	[63, "00110100"],
+	[64, "11011"],
+	[128, "10010"],
+	[192, "010111"],
+	[256, "0110111"],
+	[320, "00110110"],
+	[384, "00110111"],
+	[448, "01100100"],
+	[512, "01100101"],
+	[576, "01101000"],
+	[640, "01100111"],
+	[704, "011001100"],
+	[768, "011001101"],
+	[832, "011010010"],
+	[896, "011010011"],
+	[960, "011010100"],
+	[1024, "011010101"],
+	[1088, "011010110"],
+	[1152, "011010111"],
+	[1216, "011011000"],
+	[1280, "011011001"],
+	[1344, "011011010"],
+	[1408, "011011011"],
+	[1472, "010011000"],
+	[1536, "010011001"],
+	[1600, "010011010"],
+	[1664, "011000"],
+	[1728, "010011011"]
+];
+var BLACK_CODES = [
+	[0, "0000110111"],
+	[1, "010"],
+	[2, "11"],
+	[3, "10"],
+	[4, "011"],
+	[5, "0011"],
+	[6, "0010"],
+	[7, "00011"],
+	[8, "000101"],
+	[9, "000100"],
+	[10, "0000100"],
+	[11, "0000101"],
+	[12, "0000111"],
+	[13, "00000100"],
+	[14, "00000111"],
+	[15, "000011000"],
+	[16, "0000010111"],
+	[17, "0000011000"],
+	[18, "0000001000"],
+	[19, "00001100111"],
+	[20, "00001101000"],
+	[21, "00001101100"],
+	[22, "00000110111"],
+	[23, "00000101000"],
+	[24, "00000010111"],
+	[25, "00000011000"],
+	[26, "000011001010"],
+	[27, "000011001011"],
+	[28, "000011001100"],
+	[29, "000011001101"],
+	[30, "000001101000"],
+	[31, "000001101001"],
+	[32, "000001101010"],
+	[33, "000001101011"],
+	[34, "000011010010"],
+	[35, "000011010011"],
+	[36, "000011010100"],
+	[37, "000011010101"],
+	[38, "000011010110"],
+	[39, "000011010111"],
+	[40, "000001101100"],
+	[41, "000001101101"],
+	[42, "000011011010"],
+	[43, "000011011011"],
+	[44, "000001010100"],
+	[45, "000001010101"],
+	[46, "000001010110"],
+	[47, "000001010111"],
+	[48, "000001100100"],
+	[49, "000001100101"],
+	[50, "000001010010"],
+	[51, "000001010011"],
+	[52, "000000100100"],
+	[53, "000000110111"],
+	[54, "000000111000"],
+	[55, "000000100111"],
+	[56, "000000101000"],
+	[57, "000001011000"],
+	[58, "000001011001"],
+	[59, "000000101011"],
+	[60, "000000101100"],
+	[61, "000001011010"],
+	[62, "000001100110"],
+	[63, "000001100111"],
+	[64, "0000001111"],
+	[128, "000011001000"],
+	[192, "000011001001"],
+	[256, "000001011011"],
+	[320, "000000110011"],
+	[384, "000000110100"],
+	[448, "000000110101"],
+	[512, "0000001101100"],
+	[576, "0000001101101"],
+	[640, "0000001001010"],
+	[704, "0000001001011"],
+	[768, "0000001001100"],
+	[832, "0000001001101"],
+	[896, "0000001110010"],
+	[960, "0000001110011"],
+	[1024, "0000001110100"],
+	[1088, "0000001110101"],
+	[1152, "0000001110110"],
+	[1216, "0000001110111"],
+	[1280, "0000001010010"],
+	[1344, "0000001010011"],
+	[1408, "0000001010100"],
+	[1472, "0000001010101"],
+	[1536, "0000001011010"],
+	[1600, "0000001011011"],
+	[1664, "0000001100100"],
+	[1728, "0000001100101"]
+];
+var SHARED_MAKEUP = [
+	[1792, "00000001000"],
+	[1856, "00000001100"],
+	[1920, "00000001101"],
+	[1984, "000000010010"],
+	[2048, "000000010011"],
+	[2112, "000000010100"],
+	[2176, "000000010101"],
+	[2240, "000000010110"],
+	[2304, "000000010111"],
+	[2368, "000000011100"],
+	[2432, "000000011101"],
+	[2496, "000000011110"],
+	[2560, "000000011111"]
+];
+var MODE_CODES = [
+	["0001", {
+		kind: "pass",
+		d: 0
+	}],
+	["001", {
+		kind: "horizontal",
+		d: 0
+	}],
+	["1", {
+		kind: "vertical",
+		d: 0
+	}],
+	["011", {
+		kind: "vertical",
+		d: 1
+	}],
+	["000011", {
+		kind: "vertical",
+		d: 2
+	}],
+	["0000011", {
+		kind: "vertical",
+		d: 3
+	}],
+	["010", {
+		kind: "vertical",
+		d: -1
+	}],
+	["000010", {
+		kind: "vertical",
+		d: -2
+	}],
+	["0000010", {
+		kind: "vertical",
+		d: -3
+	}]
+];
+function buildRunTable(...groups) {
+	const map = /* @__PURE__ */ new Map();
+	let maxLen = 0;
+	for (const group of groups) for (const [run, bits] of group) {
+		map.set(bits.length << 16 | parseInt(bits, 2), run);
+		maxLen = Math.max(maxLen, bits.length);
+	}
+	return {
+		map,
+		maxLen
+	};
+}
+var WHITE = buildRunTable(WHITE_CODES, SHARED_MAKEUP);
+var BLACK = buildRunTable(BLACK_CODES, SHARED_MAKEUP);
+var MODES = new Map(MODE_CODES.map(([bits, m]) => [bits.length << 8 | parseInt(bits, 2), m]));
+//#endregion
+export { decodeCcitt };

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

@@ -1,3 +1,4 @@
+import { ShapeGradient } from '../core/vector.js';
 export interface ContentFont {
     readonly bytesPerCode: 1 | 2;
     decode: (codes: ReadonlyArray<number>) => string;
@@ -38,7 +39,10 @@ export type PathSeg = {
 };
 export interface VectorPlacement {
     readonly segs: ReadonlyArray<PathSeg>;
-    readonly fillHex: string;
+    readonly fillHex?: string;
+    readonly gradient?: ShapeGradient;
+    readonly strokeHex?: string;
+    readonly lineWidth?: number;
     readonly mcid?: number;
 }
 export interface InterpretResult {
@@ -49,4 +53,4 @@ export interface InterpretResult {
 export type Matrix = readonly [number, number, number, number, number, number];
 export declare const IDENTITY: Matrix;
 export declare function multiply(a: Matrix, b: Matrix): Matrix;
-export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix): InterpretResult;
+export declare function interpretContent(bytes: Uint8Array, fonts: ReadonlyMap<string, ContentFont>, initialCtm?: Matrix, shadings?: ReadonlyMap<string, ShapeGradient>): InterpretResult;

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

@@ -45,10 +45,13 @@ function initialState() {
 		hScale: 1,
 		leading: 0,
 		rise: 0,
-		fillColor: "000000"
+		fillColor: "000000",
+		strokeColor: "000000",
+		lineWidth: 1,
+		fillGradient: void 0
 	};
 }
-function interpretContent(bytes, fonts, initialCtm = IDENTITY) {
+function interpretContent(bytes, fonts, initialCtm = IDENTITY, shadings = /* @__PURE__ */ new Map()) {
 	const runs = [];
 	const images = [];
 	const vectors = [];
@@ -99,12 +102,22 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY) {
 		lineTo(x, y + h);
 		path.push({ op: "close" });
 	};
-	const fillPath = () => {
-		if (path.length >= 2) {
+	const ctmLineWidth = () => {
+		const m = state.ctm;
+		const scale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2])) || 1;
+		return state.lineWidth * scale;
+	};
+	const paintPath = (fill, stroke) => {
+		if (path.length >= 2 && (fill || stroke)) {
 			const mcid = mcStack.length > 0 ? mcStack[mcStack.length - 1] : void 0;
 			vectors.push({
 				segs: path,
-				fillHex: state.fillColor,
+				...fill ? { fillHex: state.fillColor } : {},
+				...fill && state.fillGradient ? { gradient: state.fillGradient } : {},
+				...stroke ? {
+					strokeHex: state.strokeColor,
+					lineWidth: ctmLineWidth()
+				} : {},
 				...mcid !== void 0 ? { mcid } : {}
 			});
 		}
@@ -247,12 +260,33 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY) {
 			}
 			case "rg":
 				state.fillColor = rgbHex(num(0), num(1), num(2));
+				state.fillGradient = void 0;
 				break;
 			case "g":
 				state.fillColor = grayHex(num(0));
+				state.fillGradient = void 0;
 				break;
 			case "k":
 				state.fillColor = cmykHex(num(0), num(1), num(2), num(3));
+				state.fillGradient = void 0;
+				break;
+			case "scn":
+			case "sc": {
+				const last = operands[operands.length - 1];
+				state.fillGradient = last instanceof PdfName ? shadings.get(last.value) : void 0;
+				break;
+			}
+			case "RG":
+				state.strokeColor = rgbHex(num(0), num(1), num(2));
+				break;
+			case "G":
+				state.strokeColor = grayHex(num(0));
+				break;
+			case "K":
+				state.strokeColor = cmykHex(num(0), num(1), num(2), num(3));
+				break;
+			case "w":
+				state.lineWidth = num(0);
 				break;
 			case "m":
 				moveTo(num(0), num(1));
@@ -272,22 +306,29 @@ function interpretContent(bytes, fonts, initialCtm = IDENTITY) {
 			case "f":
 			case "F":
 			case "f*":
+				paintPath(true, false);
+				break;
+			case "S":
+				paintPath(false, true);
+				break;
+			case "s":
+				path.push({ op: "close" });
+				paintPath(false, true);
+				break;
 			case "B":
 			case "B*":
-				fillPath();
+				paintPath(true, true);
 				break;
 			case "b":
 			case "b*":
 				path.push({ op: "close" });
-				fillPath();
+				paintPath(true, true);
 				break;
 			case "n":
-			case "S":
-			case "s":
-			case "W":
-			case "W*":
-				path = [];
+				paintPath(false, false);
 				break;
+			case "W":
+			case "W*": break;
 			default: break;
 		}
 	};
@@ -417,4 +458,4 @@ function skipInlineImage(lexer) {
 	lexer.pos = ei < 0 ? lexer.length : ei + 2;
 }
 //#endregion
-export { interpretContent, multiply };
+export { IDENTITY, interpretContent, multiply };

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

@@ -2,4 +2,4 @@ import { PdfDict, PdfValue } from '../pdf/objects.js';
 export interface Decryptor {
     decrypt: (value: PdfValue, objNum: number, gen: number) => PdfValue;
 }
-export declare function buildDecryptor(encrypt: PdfDict, idArray: PdfValue | undefined): Decryptor | undefined;
+export declare function buildDecryptor(encrypt: PdfDict, idArray: PdfValue | undefined, password?: string): Decryptor | undefined;

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

@@ -43,7 +43,7 @@ var AES_SALT = Uint8Array.from([
 ]);
 var ZERO16 = new Uint8Array(16);
 var EMPTY = new Uint8Array(0);
-function buildDecryptor(encrypt, idArray) {
+function buildDecryptor(encrypt, idArray, password = "") {
 	const filter = encrypt.get("Filter");
 	if (!(filter instanceof PdfName) || filter.value !== "Standard") return void 0;
 	const v = numOf(encrypt.get("V"));
@@ -51,12 +51,12 @@ function buildDecryptor(encrypt, idArray) {
 	let fileKey;
 	let method;
 	if (r >= 5 || v >= 5) {
-		fileKey = deriveKeyR6(strBytes(encrypt.get("U")), strBytes(encrypt.get("UE")));
+		fileKey = deriveKeyR6(strBytes(encrypt.get("U")), strBytes(encrypt.get("UE")), password);
 		method = "aesv3";
 	} else {
 		const keyLen = (numOf(encrypt.get("Length")) || 40) / 8;
 		const id0 = Array.isArray(idArray) ? strBytes(idArray[0]) : EMPTY;
-		fileKey = deriveKeyLegacy(strBytes(encrypt.get("O")), numOf(encrypt.get("P")) | 0, id0, r, Math.max(5, Math.min(16, keyLen)), encrypt.get("EncryptMetadata") !== false);
+		fileKey = deriveKeyLegacy(strBytes(encrypt.get("O")), numOf(encrypt.get("P")) | 0, id0, r, Math.max(5, Math.min(16, keyLen)), encrypt.get("EncryptMetadata") !== false, password);
 		const m = cipherMethod(encrypt, v);
 		if (m === void 0) return void 0;
 		method = m;
@@ -65,23 +65,35 @@ function buildDecryptor(encrypt, idArray) {
 	const key = fileKey;
 	return { decrypt: (value, objNum, gen) => decryptValue(value, objNum, gen, key, method) };
 }
-function deriveKeyLegacy(o, p, id0, r, keyLen, encryptMetadata) {
+function deriveKeyLegacy(o, p, id0, r, keyLen, encryptMetadata, password) {
 	const tail = r >= 4 && !encryptMetadata ? Uint8Array.from([
 		255,
 		255,
 		255,
 		255
 	]) : EMPTY;
-	let hash = md5(concat(PAD, o.subarray(0, 32), p32le(p), id0, tail));
+	let hash = md5(concat(padPassword(password), o.subarray(0, 32), p32le(p), id0, tail));
 	if (r >= 3) for (let i = 0; i < 50; i++) hash = md5(hash.subarray(0, keyLen));
 	return hash.subarray(0, keyLen);
 }
-function deriveKeyR6(u, ue) {
+function deriveKeyR6(u, ue, password) {
 	if (u.length < 48 || ue.length < 32) return void 0;
+	const pw = passwordBytes(password);
 	const validationSalt = u.subarray(32, 40);
 	const keySalt = u.subarray(40, 48);
-	if (!equal(hash2B(EMPTY, validationSalt, EMPTY), u.subarray(0, 32))) return void 0;
-	return aesCbcDecrypt(hash2B(EMPTY, keySalt, EMPTY), ZERO16, ue.subarray(0, 32), false);
+	if (!equal(hash2B(pw, validationSalt, EMPTY), u.subarray(0, 32))) return void 0;
+	return aesCbcDecrypt(hash2B(pw, keySalt, EMPTY), ZERO16, ue.subarray(0, 32), false);
+}
+function padPassword(password) {
+	const raw = strToBytes(password);
+	const out = new Uint8Array(32);
+	const n = Math.min(raw.length, 32);
+	out.set(raw.subarray(0, n), 0);
+	out.set(PAD.subarray(0, 32 - n), n);
+	return out;
+}
+function passwordBytes(password) {
+	return new TextEncoder().encode(password).subarray(0, 127);
 }
 function hash2B(pw, salt, udata) {
 	let k = sha256(concat(pw, salt, udata));

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

@@ -14,7 +14,7 @@ export declare class PdfFile {
     private decryptor;
     private encryptObjNum;
     private constructor();
-    static parse(bytes: Uint8Array): PdfFile;
+    static parse(bytes: Uint8Array, password?: string): PdfFile;
     private initEncryption;
     private readonly lengthResolver;
     resolve(value: PdfValue): PdfValue;

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

@@ -23,7 +23,7 @@ var PdfFile = class PdfFile {
 		this.xref = xref;
 		this.trailer = trailer;
 	}
-	static parse(bytes) {
+	static parse(bytes, password = "") {
 		let xref = /* @__PURE__ */ new Map();
 		let trailer = /* @__PURE__ */ new Map();
 		try {
@@ -43,17 +43,17 @@ var PdfFile = class PdfFile {
 			}
 		}
 		const file = new PdfFile(bytes, xref, trailer);
-		file.initEncryption();
+		file.initEncryption(password);
 		return file;
 	}
-	initEncryption() {
+	initEncryption(password) {
 		const encVal = this.trailer.get("Encrypt");
 		if (encVal === void 0) return;
 		if (encVal instanceof PdfRef) this.encryptObjNum = encVal.id;
 		const enc = this.resolve(encVal);
 		if (!(enc instanceof Map)) return;
 		const id = this.trailer.get("ID");
-		this.decryptor = buildDecryptor(enc, Array.isArray(id) ? id : void 0);
+		this.decryptor = buildDecryptor(enc, Array.isArray(id) ? id : void 0, password);
 	}
 	lengthResolver = (r) => {
 		const n = this.resolve(r);

package/dist/esm/pdf-reader/flow-build.js

@@ -92,11 +92,24 @@ function shapeBlock(v) {
 			case "close": return { cmd: "close" };
 		}
 	});
+	const thick = v.strokeHex !== void 0 ? Math.max(v.lineWidth ?? .75, .5) : 0;
+	const fill = v.gradient !== void 0 ? {
+		kind: "gradient",
+		gradient: v.gradient
+	} : v.fillHex !== void 0 ? {
+		kind: "solid",
+		colorHex: v.fillHex
+	} : { kind: "none" };
+	const line = v.strokeHex !== void 0 ? {
+		width: pt(thick),
+		colorHex: v.strokeHex,
+		fill: "solid"
+	} : void 0;
 	return {
 		kind: "shape",
 		shape: {
-			width: pt(w),
-			height: pt(h),
+			width: pt(Math.max(w, thick)),
+			height: pt(Math.max(h, thick)),
 			geometry: {
 				kind: "custom",
 				custom: {
@@ -105,10 +118,8 @@ function shapeBlock(v) {
 					commands
 				}
 			},
-			fill: {
-				kind: "solid",
-				colorHex: v.fillHex
-			},
+			fill,
+			...line ? { line } : {},
 			paragraphProperties: {}
 		}
 	};