reamkit 1.16.0 → 1.18.0

package/dist/esm/core/tiff.d.ts

@@ -0,0 +1,20 @@
+/** One decoded TIFF image: 8-bit chunky samples plus an optional alpha plane. */
+export interface DecodedTiff {
+    readonly width: number;
+    readonly height: number;
+    /** Samples per pixel in {@link data} — 1 (grey), 3 (RGB) or 4 (CMYK). */
+    readonly channels: 1 | 3 | 4;
+    /** Row-major 8-bit samples, `width * height * channels` long. */
+    readonly data: Uint8Array;
+    /** One byte per pixel when the file carries an alpha channel. */
+    readonly alpha?: Uint8Array;
+}
+/** Whether the bytes open with a TIFF header (§2: `II*\0` or `MM\0*`). */
+export declare function isTiff(bytes: Uint8Array): boolean;
+/**
+ * Decode the first image of a baseline TIFF into 8-bit chunky samples.
+ *
+ * @throws Error when the file is malformed or uses a feature outside baseline
+ * TIFF (planar separation, JPEG/fax compression, floating-point samples).
+ */
+export declare function decodeTiff(bytes: Uint8Array): DecodedTiff;

package/dist/esm/core/tiff.js

@@ -0,0 +1,339 @@
+import { lzwDecodeMsb } from "./lzw.js";
+import { unzlibSync } from "fflate";
+//#region src/core/tiff.ts
+var MAX_PIXELS = 4e7;
+var TAG = {
+	width: 256,
+	height: 257,
+	bitsPerSample: 258,
+	compression: 259,
+	photometric: 262,
+	fillOrder: 266,
+	stripOffsets: 273,
+	samplesPerPixel: 277,
+	rowsPerStrip: 278,
+	stripByteCounts: 279,
+	planarConfig: 284,
+	predictor: 317,
+	colorMap: 320,
+	tileWidth: 322,
+	tileLength: 323,
+	tileOffsets: 324,
+	tileByteCounts: 325,
+	extraSamples: 338,
+	sampleFormat: 339
+};
+/** Whether the bytes open with a TIFF header (§2: `II*\0` or `MM\0*`). */
+function isTiff(bytes) {
+	if (bytes.length < 8) return false;
+	const le = bytes[0] === 73 && bytes[1] === 73;
+	const be = bytes[0] === 77 && bytes[1] === 77;
+	if (!le && !be) return false;
+	return (le ? bytes[2] | bytes[3] << 8 : bytes[2] << 8 | bytes[3]) === 42;
+}
+/**
+* Decode the first image of a baseline TIFF into 8-bit chunky samples.
+*
+* @throws Error when the file is malformed or uses a feature outside baseline
+* TIFF (planar separation, JPEG/fax compression, floating-point samples).
+*/
+function decodeTiff(bytes) {
+	if (!isTiff(bytes)) throw new Error("TIFF: not a TIFF file");
+	const le = bytes[0] === 73;
+	const r = new Reader(bytes, le);
+	const ifd = r.readIfd(r.u32(4));
+	const width = num(ifd, TAG.width, 0);
+	const height = num(ifd, TAG.height, 0);
+	if (width <= 0 || height <= 0) throw new Error("TIFF: no image dimensions");
+	if (width * height > MAX_PIXELS) throw new Error("TIFF: image too large to decode");
+	const samples = num(ifd, TAG.samplesPerPixel, 1);
+	const bitsList = list(ifd, TAG.bitsPerSample, [1]);
+	const bits = bitsList[0] ?? 1;
+	if (bitsList.some((b) => b !== bits)) throw new Error("TIFF: mixed sample depths");
+	if (![
+		1,
+		2,
+		4,
+		8,
+		16
+	].includes(bits)) throw new Error(`TIFF: ${String(bits)}-bit samples`);
+	if (num(ifd, TAG.planarConfig, 1) !== 1) throw new Error("TIFF: planar separation");
+	if (list(ifd, TAG.sampleFormat, [1]).some((f) => f !== 1 && f !== 2)) throw new Error("TIFF: non-integer samples");
+	const photometric = num(ifd, TAG.photometric, samples >= 3 ? 2 : 1);
+	const compression = num(ifd, TAG.compression, 1);
+	const predictor = num(ifd, TAG.predictor, 1);
+	if (predictor !== 1 && predictor !== 2) throw new Error("TIFF: floating-point predictor");
+	const blocks = blockLayout(ifd, width, height);
+	const bytesPerRow = Math.ceil(blocks.blockWidth * samples * bits / 8);
+	const raw = new Uint8Array(width * height * samples * (bits === 16 ? 2 : 1));
+	const rawRowBytes = width * samples * (bits === 16 ? 2 : 1);
+	const blockBytes = bytesPerRow * blocks.blockHeight;
+	for (const b of blocks.blocks) {
+		const count = b.byteCount > 0 ? b.byteCount : blockBytes;
+		const rows = unpredict(decodeBlock(bytes.subarray(b.offset, b.offset + count), compression, blockBytes), predictor, bytesPerRow, samples, bits, le);
+		for (let y = 0; y < blocks.blockHeight; y++) {
+			const destY = b.y + y;
+			if (destY >= height) break;
+			const src = y * bytesPerRow;
+			if (src >= rows.length) break;
+			const row = expandRow(rows.subarray(src, src + bytesPerRow), bits, blocks.blockWidth * samples);
+			const keep = Math.min(row.length, (width - b.x) * samples * (bits === 16 ? 2 : 1));
+			raw.set(row.subarray(0, keep), destY * rawRowBytes + b.x * samples * (bits === 16 ? 2 : 1));
+		}
+	}
+	return toChannels(bits === 16 ? highBytes(raw, le) : raw, {
+		width,
+		height,
+		samples,
+		bits,
+		photometric,
+		palette: list(ifd, TAG.colorMap, []),
+		extra: list(ifd, TAG.extraSamples, [])
+	});
+}
+var TYPE_SIZE = new Map([
+	[1, 1],
+	[2, 1],
+	[3, 2],
+	[4, 4],
+	[5, 8],
+	[6, 1],
+	[7, 1],
+	[8, 2],
+	[9, 4],
+	[10, 8],
+	[11, 4],
+	[12, 8]
+]);
+var Reader = class {
+	constructor(b, le) {
+		this.b = b;
+		this.le = le;
+	}
+	u16(o) {
+		if (o + 2 > this.b.length) throw new Error("TIFF: truncated");
+		return this.le ? this.b[o] | this.b[o + 1] << 8 : this.b[o] << 8 | this.b[o + 1];
+	}
+	u32(o) {
+		if (o + 4 > this.b.length) throw new Error("TIFF: truncated");
+		return this.le ? (this.b[o] | this.b[o + 1] << 8 | this.b[o + 2] << 16) + this.b[o + 3] * 16777216 : (this.b[o + 3] | this.b[o + 2] << 8 | this.b[o + 1] << 16) + this.b[o] * 16777216;
+	}
+	/** §2 — the directory at `offset`: a count, then 12-byte entries. */
+	readIfd(offset) {
+		const count = this.u16(offset);
+		const out = /* @__PURE__ */ new Map();
+		for (let i = 0; i < count; i++) {
+			const e = offset + 2 + i * 12;
+			const tag = this.u16(e);
+			const type = this.u16(e + 2);
+			const n = this.u32(e + 4);
+			const size = TYPE_SIZE.get(type) ?? 0;
+			if (size === 0 || n > 1e6) continue;
+			const at = size * n <= 4 ? e + 8 : this.u32(e + 8);
+			out.set(tag, {
+				type,
+				count: n,
+				values: this.readValues(type, n, at)
+			});
+		}
+		return out;
+	}
+	readValues(type, count, at) {
+		const size = TYPE_SIZE.get(type) ?? 1;
+		const out = [];
+		for (let i = 0; i < count; i++) {
+			const o = at + i * size;
+			if (o + size > this.b.length) break;
+			switch (type) {
+				case 1:
+				case 2:
+				case 6:
+				case 7:
+					out.push(this.b[o]);
+					break;
+				case 3:
+					out.push(this.u16(o));
+					break;
+				case 8: {
+					const v = this.u16(o);
+					out.push(v > 32767 ? v - 65536 : v);
+					break;
+				}
+				case 4:
+					out.push(this.u32(o));
+					break;
+				case 9: {
+					const v = this.u32(o);
+					out.push(v > 2147483647 ? v - 4294967296 : v);
+					break;
+				}
+				case 5:
+				case 10: {
+					const d = this.u32(o + 4);
+					out.push(d === 0 ? 0 : this.u32(o) / d);
+					break;
+				}
+				default: out.push(0);
+			}
+		}
+		return out;
+	}
+};
+function num(ifd, tag, fallback) {
+	return ifd.get(tag)?.values[0] ?? fallback;
+}
+function list(ifd, tag, fallback) {
+	const e = ifd.get(tag);
+	return e && e.values.length > 0 ? e.values : fallback;
+}
+function blockLayout(ifd, width, height) {
+	const tileW = num(ifd, TAG.tileWidth, 0);
+	const tileH = num(ifd, TAG.tileLength, 0);
+	if (tileW > 0 && tileH > 0) {
+		const offsets = list(ifd, TAG.tileOffsets, []);
+		const counts = list(ifd, TAG.tileByteCounts, []);
+		const across = Math.ceil(width / tileW);
+		return {
+			blocks: offsets.map((offset, i) => ({
+				offset,
+				byteCount: counts[i] ?? 0,
+				x: i % across * tileW,
+				y: Math.floor(i / across) * tileH
+			})),
+			blockWidth: tileW,
+			blockHeight: tileH
+		};
+	}
+	const rows = num(ifd, TAG.rowsPerStrip, height) || height;
+	const offsets = list(ifd, TAG.stripOffsets, []);
+	const counts = list(ifd, TAG.stripByteCounts, []);
+	if (offsets.length === 0) throw new Error("TIFF: no image data");
+	return {
+		blocks: offsets.map((offset, i) => ({
+			offset,
+			byteCount: counts[i] ?? 0,
+			x: 0,
+			y: i * rows
+		})),
+		blockWidth: width,
+		blockHeight: rows
+	};
+}
+function decodeBlock(data, compression, expected) {
+	switch (compression) {
+		case 1: return data;
+		case 5: return lzwDecodeMsb(data, { limit: expected });
+		case 8:
+		case 32946: try {
+			return unzlibSync(data);
+		} catch {
+			throw new Error("TIFF: corrupt Deflate strip");
+		}
+		case 32773: return packBits(data, expected);
+		default: throw new Error(`TIFF: compression ${String(compression)}`);
+	}
+}
+function packBits(data, expected) {
+	const out = new Uint8Array(expected);
+	let o = 0;
+	for (let i = 0; i < data.length && o < expected;) {
+		const n = data[i++];
+		if (n === 128) continue;
+		if (n < 128) {
+			const run = Math.min(n + 1, data.length - i, expected - o);
+			out.set(data.subarray(i, i + run), o);
+			i += n + 1;
+			o += run;
+		} else {
+			const byte = data[i++] ?? 0;
+			const run = Math.min(257 - n, expected - o);
+			out.fill(byte, o, o + run);
+			o += run;
+		}
+	}
+	return out.subarray(0, o);
+}
+function unpredict(data, predictor, rowBytes, samples, bits, le) {
+	if (predictor !== 2 || rowBytes <= 0) return data;
+	if (bits !== 8 && bits !== 16) return data;
+	const out = data.slice();
+	const rows = Math.floor(out.length / rowBytes);
+	if (bits === 8) {
+		for (let r = 0; r < rows; r++) {
+			const off = r * rowBytes;
+			for (let i = samples; i < rowBytes; i++) out[off + i] = out[off + i] + out[off + i - samples] & 255;
+		}
+		return out;
+	}
+	const stride = samples * 2;
+	const hi = le ? 1 : 0;
+	const lo = le ? 0 : 1;
+	for (let r = 0; r < rows; r++) {
+		const off = r * rowBytes;
+		for (let i = stride; i + 1 < rowBytes; i += 2) {
+			const prev = out[off + i - stride + hi] << 8 | out[off + i - stride + lo];
+			const v = (out[off + i + hi] << 8 | out[off + i + lo]) + prev & 65535;
+			out[off + i + hi] = v >> 8;
+			out[off + i + lo] = v & 255;
+		}
+	}
+	return out;
+}
+function expandRow(row, bits, samplesInRow) {
+	if (bits >= 8) return row;
+	const out = new Uint8Array(samplesInRow);
+	const max = (1 << bits) - 1;
+	for (let i = 0; i < samplesInRow; i++) {
+		const bit = i * bits;
+		const byte = row[bit >> 3] ?? 0;
+		const shift = 8 - bits - (bit & 7);
+		out[i] = Math.round((byte >> shift & max) * 255 / max);
+	}
+	return out;
+}
+function highBytes(raw, le) {
+	const out = new Uint8Array(raw.length >> 1);
+	const hi = le ? 1 : 0;
+	for (let i = 0; i < out.length; i++) out[i] = raw[i * 2 + hi];
+	return out;
+}
+function toChannels(eight, info) {
+	const pixels = info.width * info.height;
+	const { photometric, samples } = info;
+	if (photometric === 3) {
+		const rgb = new Uint8Array(pixels * 3);
+		const entries = info.palette.length / 3;
+		for (let i = 0; i < pixels; i++) {
+			const idx = eight[i * samples] ?? 0;
+			const e = info.bits < 8 ? Math.round(idx * ((1 << info.bits) - 1) / 255) : idx;
+			rgb[i * 3] = (info.palette[e] ?? 0) >> 8;
+			rgb[i * 3 + 1] = (info.palette[entries + e] ?? 0) >> 8;
+			rgb[i * 3 + 2] = (info.palette[entries * 2 + e] ?? 0) >> 8;
+		}
+		return {
+			width: info.width,
+			height: info.height,
+			channels: 3,
+			data: rgb
+		};
+	}
+	const color = photometric === 5 ? 4 : photometric === 2 ? 3 : 1;
+	if (samples < color) throw new Error("TIFF: too few samples for its colour");
+	const alphaAt = info.extra.length > 0 && samples > color ? color : -1;
+	const data = samples === color ? eight.subarray(0, pixels * color) : new Uint8Array(pixels * color);
+	const alpha = alphaAt >= 0 ? new Uint8Array(pixels) : void 0;
+	if (samples !== color) for (let i = 0; i < pixels; i++) {
+		for (let c = 0; c < color; c++) data[i * color + c] = eight[i * samples + c] ?? 0;
+		if (alpha) alpha[i] = eight[i * samples + alphaAt] ?? 255;
+	}
+	if (photometric === 0) for (let i = 0; i < data.length; i++) data[i] = 255 - data[i];
+	return {
+		width: info.width,
+		height: info.height,
+		channels: color === 4 ? 4 : color === 3 ? 3 : 1,
+		data,
+		...alpha ? { alpha } : {}
+	};
+}
+//#endregion
+export { decodeTiff, isTiff };

package/dist/esm/core/vector.d.ts

@@ -60,6 +60,23 @@ export interface ShapeGradient {
     readonly kind: 'linear' | 'radial';
     /** Linear only: gradient direction in degrees clockwise (0 = left→right). */
     readonly angle?: number;
+    /**
+     * Radial only: where the first stop sits inside the box, as fractions of it
+     * (`{x: 0, y: 0}` is the top-left corner). Absent means the middle, which is
+     * where DrawingML's own `a:path` puts it; VML aims it at a corner instead
+     * (`@focus` with an `@angle`), and fill.docx's page sweep starts in one.
+     */
+    readonly center?: {
+        readonly x: number;
+        readonly y: number;
+    };
+    /**
+     * Radial only: the shape of the sweep's contours. Circles by default, which
+     * is what DrawingML's `a:path path="circle"` draws; VML's `gradientRadial`
+     * grows RECTANGLES out to the box instead, and so does the page background
+     * of fill.docx.
+     */
+    readonly sweep?: 'circle' | 'rect';
     readonly stops: ReadonlyArray<GradientStop>;
 }
 /**
@@ -80,6 +97,11 @@ export interface VectorShape {
      * over `fillColorHex`.
      */
     readonly fillGradient?: ShapeGradient;
+    /**
+     * §20.1.2.3.1 — the fill's opacity, `0..1`. Absent is opaque. Writers without
+     * transparency paint `fillColorHex` at full strength.
+     */
+    readonly fillAlpha?: number;
     /** Stroke description. Omitted = no stroke. */
     readonly stroke?: StrokeStyle;
     /**

package/dist/esm/excel/print-model.js

@@ -873,6 +873,7 @@ function worksheetToBody(worksheet, sharedStrings, styles, date1904, print) {
 		const rowHeightTwips = scaled && baseRowProps !== void 0 ? Math.max(1, Math.round(baseRowProps.heightTwips * printScale)) : baseRowProps?.heightTwips;
 		const isTitleRow = print.titleRows !== void 0 && absR >= print.titleRows.startRow && absR <= print.titleRows.endRow;
 		const rowProps = {
+			cantSplit: true,
 			...rowHeightTwips !== void 0 ? {
 				height: twipsToPt(rowHeightTwips),
 				heightRule: baseRowProps?.heightRule ?? "atLeast"
@@ -1237,7 +1238,7 @@ function mapBorderStyle(style) {
 			sizeEighthPt: 18
 		};
 		case "dashed": return {
-			style: "dashed",
+			style: "dashSmallGap",
 			sizeEighthPt: 6
 		};
 		case "dashDot": return {
@@ -1736,7 +1737,8 @@ function slicerTable(slicer) {
 	};
 	const rowProps = {
 		height: pt(SLICER_ROW_PT),
-		heightRule: "atLeast"
+		heightRule: "atLeast",
+		cantSplit: true
 	};
 	const rows = [];
 	rows.push({

package/dist/esm/excel/sheet-to-flow.js

@@ -6,6 +6,14 @@ import { buildHeaderFooterContent } from "./header-footer.js";
 //#region src/excel/sheet-to-flow.ts
 var HEADER_REL = "_xlsxHeaderDefault";
 var FOOTER_REL = "_xlsxFooterDefault";
+var PAGE_BREAK_PARAGRAPH = {
+	properties: {
+		pageBreakBefore: true,
+		spacingLine: pt(0),
+		spacingLineRule: "exact"
+	},
+	runs: []
+};
 /**
 * Project a {@link SheetDoc} into a {@link FlowDoc} (E-SHEET SA2): each grid sheet
 * becomes flow blocks (a table + chart/picture/shape/slicer frames, then comment
@@ -61,10 +69,7 @@ function projectSheetDoc(sheet, options = {}) {
 		sheetSections.push(sheetSection);
 		if (printed > 0) body.push({
 			kind: "paragraph",
-			paragraph: {
-				properties: { pageBreakBefore: true },
-				runs: []
-			}
+			paragraph: PAGE_BREAK_PARAGRAPH
 		});
 		const drawings = [];
 		for (const ref of ws.charts ?? []) drawings.push({
@@ -96,10 +101,7 @@ function projectSheetDoc(sheet, options = {}) {
 		for (let band = 0; band < drawingBands.length; band++) {
 			if (band > 0) drawings.push({
 				kind: "paragraph",
-				paragraph: {
-					properties: { pageBreakBefore: true },
-					runs: []
-				}
+				paragraph: PAGE_BREAK_PARAGRAPH
 			});
 			for (const shape of drawingBands[band]) drawings.push({
 				kind: "shape",

package/dist/esm/excel/worksheet-parser.js

@@ -1,7 +1,7 @@
 import { INDEXED_COLORS } from "../core/indexed-colors.js";
+import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { parseCellRef } from "./cell-reference.js";
 import { parseAreaRef } from "./defined-name-ref.js";
-import { resolveInternalEntities } from "../core/opc/xml-entities.js";
 import { decodeXstring } from "./escaped-text.js";
 import { parseDxf } from "./styles-parser.js";
 import { XMLParser } from "fast-xml-parser";

package/dist/esm/html/html-writer.js

@@ -1,8 +1,8 @@
 import { FEATURES } from "../core/ir/features.js";
 import { detectImageFormat } from "../core/images.js";
+import { PathBuilder, flipTransform, svgPathData } from "../core/vector.js";
 import { EMPTY_STYLE_SHEET, resolveParagraphProperties, resolveRunProperties } from "../core/style-cascade/resolver.js";
 import "../core/style-cascade/index.js";
-import { PathBuilder, flipTransform, svgPathData } from "../core/vector.js";
 import { buildSparkline } from "../core/drawingml/sparkline-geometry.js";
 import { arcPoint, arcToBeziers } from "../core/arc-to-bezier.js";
 import { buildChartScene } from "../core/drawingml/chart-geometry.js";
@@ -106,7 +106,11 @@ function collectReferencedAnchors(body) {
 		for (const el of els) if (el.kind === "paragraph") {
 			for (const r of el.paragraph.runs) if (r.anchor !== void 0) out.add(r.anchor);
 		} else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape" && el.shape.text) visit(el.shape.text.content);
+		else if (el.kind === "shape") visitShape(el.shape);
+	};
+	const visitShape = (shape) => {
+		if (shape.text) visit(shape.text.content);
+		for (const child of shape.children ?? []) visitShape(child.shape);
 	};
 	visit(body);
 	return out;
@@ -122,7 +126,11 @@ function collectNoteNumbers(flow) {
 			if (r.commentRef !== void 0 && !comments.has(r.commentRef)) comments.set(r.commentRef, comments.size + 1);
 		}
 		else if (el.kind === "table") for (const row of el.table.rows) for (const cell of row.cells) visit(cell.content);
-		else if (el.kind === "shape" && el.shape.text) visit(el.shape.text.content);
+		else if (el.kind === "shape") visitShape(el.shape);
+	};
+	const visitShape = (shape) => {
+		if (shape.text) visit(shape.text.content);
+		for (const child of shape.children ?? []) visitShape(child.shape);
 	};
 	visit(flow.body);
 	return {
@@ -274,6 +282,11 @@ function hexToRgbCss(hex) {
 	return `${String(n >> 16 & 255)},${String(n >> 8 & 255)},${String(n & 255)}`;
 }
 function emitShapeBlock(out, shape, ctx) {
+	const children = shape.children ?? [];
+	if (!(children.length > 0 && shape.fill.kind === "none" && shape.line === void 0 && (shape.text?.content.length ?? 0) === 0)) emitOneShape(out, shape, ctx);
+	for (const child of children) emitShapeBlock(out, child.shape, ctx);
+}
+function emitOneShape(out, shape, ctx) {
 	const w = shape.width;
 	const h = shape.height;
 	const paths = buildShapePaths(shape.geometry, w, h);
@@ -620,7 +633,7 @@ function pieIconSvg(fill, color, empty) {
 function pushBorder(css, side, border) {
 	if (!border || border.style === "none") return;
 	const width = border.width ?? .5;
-	const style = border.style === "double" ? "double" : border.style === "dotted" ? "dotted" : border.style === "dashed" ? "dashed" : "solid";
+	const style = border.style === "double" ? "double" : border.style === "dotted" ? "dotted" : border.style === "dashed" || border.style === "dashSmallGap" ? "dashed" : "solid";
 	css.push(`border-${side}:${fmt(width)}pt ${style} #${border.colorHex ?? "000000"}`);
 }
 function emitImageBlock(out, image, ctx) {
@@ -638,7 +651,9 @@ function emitImageBlock(out, image, ctx) {
 var MIME_BY_FORMAT = {
 	jpeg: "image/jpeg",
 	png: "image/png",
-	jpeg2000: "image/jp2"
+	jpeg2000: "image/jp2",
+	gif: "image/gif",
+	tiff: "image/tiff"
 };
 function dataUri(resource, store) {
 	if (resource === void 0) return void 0;