reamkit 1.17.0 → 1.18.0

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

@@ -97,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"
@@ -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/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";
@@ -652,7 +652,8 @@ var MIME_BY_FORMAT = {
 	jpeg: "image/jpeg",
 	png: "image/png",
 	jpeg2000: "image/jp2",
-	gif: "image/gif"
+	gif: "image/gif",
+	tiff: "image/tiff"
 };
 function dataUri(resource, store) {
 	if (resource === void 0) return void 0;

package/dist/esm/layout/page-doc.d.ts

@@ -2,8 +2,9 @@ import { BorderStyle, ImageCrop, PictureOutline, ShapeShadow } from '../core/doc
 import { Pt, ResourceId, ResourceStore } from '../core/ir/index.js';
 import { FontMeasure, ParsedTtf } from '../core/font/index.js';
 import { ResolvedParagraphProperties, ResolvedRunProperties } from '../core/style-cascade/index.js';
-import { PathSegment, VectorPath, VectorShape } from '../core/vector.js';
+import { PathSegment, StrokeStyle, VectorPath, VectorShape } from '../core/vector.js';
 import { PreparedImage } from '../core/images.js';
+import { MetaPicture } from '../core/metafile/picture.js';
 /** A font bound into a {@link LaidOutDocument}: the parsed face plus what layout/emit need from it. */
 export interface FontResource {
     readonly resourceName: string;
@@ -84,6 +85,17 @@ export interface ImageToken {
     readonly outline?: PictureOutline;
     /** §20.1.8.40 — the drop shadow under the picture, when it casts one. */
     readonly shadow?: ShapeShadow;
+    /** §14.1.2.10 — the contrast/brightness wash the picture is drawn through. */
+    readonly wash?: {
+        readonly gain: number;
+        readonly black: number;
+    };
+    /**
+     * MS-EMF / MS-WMF — the picture to DRAW in this token's box, for an inline
+     * metafile: it has no raster to place, so the emitter plays its primitives
+     * where the token stands.
+     */
+    readonly metafile?: MetafileDrawing;
     /** §20.1.8.55 `a:srcRect` — the part of the source the frame shows. */
     readonly crop?: ImageCrop;
     /** §20.1.7.6 — degrees clockwise about the box's centre. */
@@ -175,13 +187,39 @@ export interface Line {
     readonly metricDescentPt?: number;
 }
 /** An image bound into a {@link LaidOutDocument}: its resource name plus the decoded/validated bytes. */
+/**
+ * MS-EMF / MS-WMF — a metafile picture, ready to draw: paths and words in a
+ * local y-up frame whose origin is the picture box's bottom-left corner. The
+ * same vocabulary a chart's layout carries, because a metafile draws the same
+ * two things.
+ */
+export interface MetafileDrawing {
+    readonly shapes: ReadonlyArray<{
+        readonly paths: ReadonlyArray<VectorPath>;
+        readonly fillColorHex?: string;
+        readonly stroke?: StrokeStyle;
+    }>;
+    readonly texts: ReadonlyArray<{
+        readonly line: Line;
+        readonly x: number;
+        readonly y: number;
+        readonly rotationDeg?: number;
+    }>;
+}
 export interface ImageResource {
     readonly resourceName: string;
     /**
      * Decoded/validated at layout time (the probe); the emit phase replays it
-     * without touching the source bytes again.
+     * without touching the source bytes again. Absent for a METAFILE, which has
+     * no raster to embed: it is drawn as the primitives `metafile` holds.
      */
-    readonly prepared: PreparedImage;
+    readonly prepared?: PreparedImage;
+    /**
+     * MS-EMF / MS-WMF — the picture read out of the resource, in its own logical
+     * units. A metafile is a little drawing program, not a raster; the layout
+     * turns these into the same primitives a chart is made of.
+     */
+    readonly metafile?: MetaPicture;
 }
 /**
  * The fields every {@link PageItem} shares (ir-design §6, frozen at stage 6.4):
@@ -271,6 +309,11 @@ export interface ImageItem extends PageItemBase {
     readonly imageResourceName: string;
     /** §20.1.8.55 `a:srcRect` — the part of the source the frame shows. */
     readonly crop?: ImageCrop;
+    /** §14.1.2.10 — the contrast/brightness wash the picture is drawn through. */
+    readonly wash?: {
+        readonly gain: number;
+        readonly black: number;
+    };
     /** §20.1.7.6 — degrees clockwise about the box's centre. */
     readonly rotationDeg?: number;
     /** §20.1.7.6 — the picture drawn mirrored in its box. */