reamkit 1.17.0 → 1.19.0

package/dist/esm/core/document-model/types.d.ts

@@ -248,6 +248,15 @@ export interface InlineImage {
      * six stood flat on the page where both references lift them off it.
      */
     readonly shadow?: ShapeShadow;
+    /**
+     * §14.1.2.10 `@gain`/`@blacklevel` — the contrast and brightness the picture
+     * is drawn through, about mid grey: `out = (in - 0.5) * gain + 0.5 + black`.
+     * Word washes a watermark out this way.
+     */
+    readonly wash?: {
+        readonly gain: number;
+        readonly black: number;
+    };
     readonly width: Pt;
     readonly height: Pt;
     /** §20.1.8.55 `a:srcRect` — the part of the source the frame shows. */
@@ -897,6 +906,15 @@ export interface ImageBlock {
      * six stood flat on the page where both references lift them off it.
      */
     readonly shadow?: ShapeShadow;
+    /**
+     * §14.1.2.10 `@gain`/`@blacklevel` — the contrast and brightness the picture
+     * is drawn through, about mid grey: `out = (in - 0.5) * gain + 0.5 + black`.
+     * Word washes a watermark out this way.
+     */
+    readonly wash?: {
+        readonly gain: number;
+        readonly black: number;
+    };
     readonly width: Pt;
     readonly height: Pt;
     /** §20.1.8.55 `a:srcRect` — the part of the source the frame shows. */
@@ -974,6 +992,12 @@ export interface ShapeFill {
     readonly kind: ShapeFillKind;
     readonly colorHex?: string;
     readonly gradient?: ShapeGradient;
+    /**
+     * §14.1.2.5 `@type="tile"` — the picture REPEATS at its own size rather than
+     * stretching over the box. A parchment behind a page, a texture behind a
+     * text box: stretched, such a fill is a blur where it should be a pattern.
+     */
+    readonly tiled?: boolean;
     /**
      * §20.1.8.14 `a:blipFill` — the picture painted across the shape's box. A
      * DrawingML picture IS a shape with one of these, which is how a `pic:pic`
@@ -985,6 +1009,12 @@ export interface ShapeFill {
      * of the picture the box shows, as the fractions cut from each side.
      */
     readonly imageCrop?: ImageCrop;
+    /**
+     * §20.1.2.3.1 `a:alpha` / §14.1.2.5 `@opacity` — how opaque the fill is,
+     * `0..1`. Absent is opaque. The colour above is the fill's own, NOT composited
+     * over the paper: what is behind the shape shows through it.
+     */
+    readonly alpha?: number;
 }
 /** §20.1.10.49 ST_PresetLineDashVal — a shape outline's preset dash pattern. */
 export type ShapeDash = 'solid' | 'dot' | 'dash' | 'dashDot' | 'lgDash' | 'lgDashDot' | 'sysDash' | 'sysDot';
@@ -1063,6 +1093,16 @@ export interface ShapeTextBody {
      * WordArt is set at whatever size fills the box it was drawn in.
      */
     readonly fitToBox?: boolean;
+    /**
+     * `wps:txbx @id` / `wps:linkedTxbx @id @seq` — the chain of boxes this one
+     * belongs to. Text that overruns a box continues in the next of its chain;
+     * `seq` 0 is the box that holds the words, and the rest carry none of their
+     * own.
+     */
+    readonly chain?: {
+        readonly id: string;
+        readonly seq: number;
+    };
 }
 /**
  * A block-level DrawingML shape (§20.1): its size, {@link ShapeGeometry}, fill,
@@ -1417,7 +1457,12 @@ export interface SectionProperties {
  * modes (square/tight/through) and `topAndBottom` stay in flow as blocks.
  */
 export interface FloatAnchor {
-    readonly wrap: 'none' | 'square' | 'tight' | 'through' | 'topAndBottom';
+    /**
+     * §20.4.2.3 / §17.18.104 — how body text runs past the drawing. `notBeside`
+     * is the FRAME's own mode: the drawing keeps the place its anchor names, but
+     * no text may stand beside it, so its band spans the whole column.
+     */
+    readonly wrap: 'none' | 'square' | 'tight' | 'through' | 'topAndBottom' | 'notBeside';
     readonly behind?: boolean;
     /**
      * §20.4.2.3 `wp:anchor @relativeHeight` — the z-order among the floats on the
@@ -1451,6 +1496,19 @@ export interface FloatAnchor {
          */
         readonly align?: 'top' | 'center' | 'bottom';
     };
+    /**
+     * §20.4.2.3 `@wrapText` on the wrap element — which side(s) of the drawing
+     * text may stand on. `bothSides` is the default and the only value that
+     * fills BOTH gaps; `left`/`right` name one, `largest` the wider.
+     */
+    readonly wrapSide?: 'bothSides' | 'left' | 'right' | 'largest';
+    /**
+     * §20.4.2.3 `wp:anchor @layoutInCell` (VML `o:allowincell`) — present and
+     * false when a drawing anchored inside a TABLE CELL is placed against the
+     * page rather than against the cell. Absent means the default: the cell is
+     * the frame every `relativeFrom` is measured in.
+     */
+    readonly inCell?: boolean;
     /**
      * §20.4.2.3 `wp:anchor @distT/@distB/@distL/@distR` — how far the wrapped
      * text stands off each edge of the drawing. Absent sides are 0.

package/dist/esm/core/drawingml/colors.js

@@ -69,6 +69,13 @@ function hslToRgb(h, s, l) {
 		b + m
 	];
 }
+function toLinear(c) {
+	return c <= .04045 ? c / 12.92 : Math.pow((c + .055) / 1.055, 2.4);
+}
+function toSrgb(c) {
+	const v = clamp01(c);
+	return v <= .0031308 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - .055;
+}
 /**
 * Apply DrawingML colour transforms ({@link ColorMod}s) to a 6-hex value,
 * returning a 6-hex value. `shade`/`tint` scale in RGB; `lumMod`/`lumOff` adjust
@@ -85,13 +92,13 @@ function applyColorMods(hex, mods) {
 	let g = (n >> 8 & 255) / 255;
 	let b = (n & 255) / 255;
 	for (const m of mods) if (m.kind === "shade") {
-		r *= m.val;
-		g *= m.val;
-		b *= m.val;
+		r = toSrgb(toLinear(r) * m.val);
+		g = toSrgb(toLinear(g) * m.val);
+		b = toSrgb(toLinear(b) * m.val);
 	} else if (m.kind === "tint") {
-		r = r * m.val + (1 - m.val);
-		g = g * m.val + (1 - m.val);
-		b = b * m.val + (1 - m.val);
+		r = toSrgb(toLinear(r) * m.val + (1 - m.val));
+		g = toSrgb(toLinear(g) * m.val + (1 - m.val));
+		b = toSrgb(toLinear(b) * m.val + (1 - m.val));
 	} else if (m.kind === "lumMod" || m.kind === "lumOff") {
 		const [h, s, l] = rgbToHsl(r, g, b);
 		const l2 = m.kind === "lumMod" ? l * m.val : clamp01(l + m.val);

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

@@ -1,5 +1,5 @@
 /** The raster formats this module recognizes and can prepare for embedding. */
-export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif';
+export type ImageFormat = 'jpeg' | 'png' | 'jpeg2000' | 'gif' | 'tiff';
 /**
  * Sniff the raster format from a file's leading magic bytes (JPEG SOI, the PNG
  * signature, or a JP2 box / raw JPEG 2000 codestream). Returns the
@@ -24,7 +24,7 @@ export interface EmbedImageOptions {
  */
 export interface PreparedImage {
     readonly format: ImageFormat;
-    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif';
+    readonly mimeType: 'image/jp2' | 'image/jpeg' | 'image/png' | 'image/gif' | 'image/tiff';
     readonly widthPx: number;
     readonly heightPx: number;
     /**

package/dist/esm/core/images.js

@@ -1,3 +1,4 @@
+import { decodeTiff, isTiff } from "./tiff.js";
 import { unzlibSync, zlibSync } from "fflate";
 //#region src/core/images.ts
 /**
@@ -11,6 +12,7 @@ function detectImageFormat(bytes) {
 	if (bytes.length >= 12 && bytes[0] === 0 && bytes[1] === 0 && bytes[2] === 0 && bytes[3] === 12 && bytes[4] === 106 && bytes[5] === 80 && bytes[6] === 32 && bytes[7] === 32 && bytes[8] === 13 && bytes[9] === 10 && bytes[10] === 135 && bytes[11] === 10) return "jpeg2000";
 	if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 79 && bytes[2] === 255 && bytes[3] === 81) return "jpeg2000";
 	if (bytes.length >= 6 && bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97) return "gif";
+	if (isTiff(bytes)) return "tiff";
 	return null;
 }
 /**
@@ -26,6 +28,7 @@ function prepareImage(bytes, options = {}) {
 	if (format === "png") return preparePng(bytes, options);
 	if (format === "jpeg2000") return prepareJpeg2000(bytes);
 	if (format === "gif") return prepareGif(bytes, options);
+	if (format === "tiff") return prepareTiff(bytes, options);
 	throw new Error("Unsupported image format");
 }
 function prepareJpeg2000(bytes) {
@@ -170,6 +173,41 @@ function prepareGif(bytes, options = {}) {
 		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha) } : {}
 	};
 }
+function prepareTiff(bytes, options = {}) {
+	const img = decodeTiff(bytes);
+	const channels = img.channels === 4 ? 3 : img.channels;
+	const data = img.channels === 4 ? cmykToRgb(img.data) : img.data.slice();
+	const alpha = img.alpha;
+	if (alpha && options.flattenAlpha) for (let i = 0; i < alpha.length; i++) {
+		if (alpha[i] === 255) continue;
+		const a = alpha[i] / 255;
+		for (let c = 0; c < channels; c++) {
+			const at = i * channels + c;
+			data[at] = Math.round(data[at] * a + 255 * (1 - a));
+		}
+	}
+	return {
+		format: "tiff",
+		mimeType: "image/tiff",
+		widthPx: img.width,
+		heightPx: img.height,
+		colorSpace: channels === 3 ? "DeviceRGB" : "DeviceGray",
+		bitsPerComponent: 8,
+		filter: "FlateDecode",
+		data: zlibSync(data),
+		...alpha && !options.flattenAlpha ? { smaskData: zlibSync(alpha.slice()) } : {}
+	};
+}
+function cmykToRgb(cmyk) {
+	const out = new Uint8Array(cmyk.length / 4 * 3);
+	for (let i = 0; i * 4 + 3 < cmyk.length; i++) {
+		const k = 255 - cmyk[i * 4 + 3];
+		out[i * 3] = (255 - cmyk[i * 4]) * k / 255;
+		out[i * 3 + 1] = (255 - cmyk[i * 4 + 1]) * k / 255;
+		out[i * 3 + 2] = (255 - cmyk[i * 4 + 2]) * k / 255;
+	}
+	return out;
+}
 function decodeGif(bytes) {
 	const u16 = (i) => (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8;
 	const screenW = u16(6);

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

@@ -0,0 +1,17 @@
+/** How to run {@link lzwDecodeMsb}: the early-change flag and an output cap. */
+export interface LzwOptions {
+    /**
+     * Widen the code one step BEFORE the table fills (PDF `/EarlyChange`,
+     * TIFF's own convention). 1 by default, matching both specifications' norm.
+     */
+    readonly earlyChange?: number;
+    /** Stop after this many output bytes — the guard against a decompression bomb. */
+    readonly limit: number;
+}
+/**
+ * Decode an MSB-first LZW stream (TIFF 6.0 §13 / ISO 32000-1 §7.4.4.2). The
+ * KwKwK case (a code not yet in the table) repeats the previous string plus its
+ * own first byte. Truncated input ends the stream where it stops rather than
+ * throwing: a partly-decoded strip still prints.
+ */
+export declare function lzwDecodeMsb(data: Uint8Array, options: LzwOptions): Uint8Array;

package/dist/esm/core/lzw.js

@@ -0,0 +1,83 @@
+//#region src/core/lzw.ts
+/**
+* Decode an MSB-first LZW stream (TIFF 6.0 §13 / ISO 32000-1 §7.4.4.2). The
+* KwKwK case (a code not yet in the table) repeats the previous string plus its
+* own first byte. Truncated input ends the stream where it stops rather than
+* throwing: a partly-decoded strip still prints.
+*/
+function lzwDecodeMsb(data, options) {
+	const earlyChange = options.earlyChange ?? 1;
+	let out = new Uint8Array(4096);
+	let outLen = 0;
+	const emit = (e) => {
+		if (outLen + e.length > options.limit) return false;
+		if (outLen + e.length > out.length) {
+			let cap = out.length * 2;
+			while (cap < outLen + e.length) cap *= 2;
+			const grown = new Uint8Array(cap);
+			grown.set(out.subarray(0, outLen));
+			out = grown;
+		}
+		out.set(e, outLen);
+		outLen += e.length;
+		return true;
+	};
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let pos = 0;
+	let codeLength = 9;
+	const readCode = () => {
+		while (bitCount < codeLength) {
+			if (pos >= data.length) return -1;
+			bitBuffer = (bitBuffer << 8 | data[pos++]) >>> 0;
+			bitCount += 8;
+		}
+		bitCount -= codeLength;
+		return bitBuffer >>> bitCount & (1 << codeLength) - 1;
+	};
+	const dict = new Array(4096);
+	let nextCode = 258;
+	let prev = -1;
+	const reset = () => {
+		for (let i = 0; i < 256; i++) dict[i] = Uint8Array.of(i);
+		nextCode = 258;
+		codeLength = 9;
+		prev = -1;
+	};
+	reset();
+	for (;;) {
+		const code = readCode();
+		if (code < 0 || code === 257) break;
+		if (code === 256) {
+			reset();
+			continue;
+		}
+		if (prev < 0) {
+			const first = dict[code];
+			if (!first || !emit(first)) break;
+			prev = code;
+			continue;
+		}
+		const prevEntry = dict[prev];
+		let entry = code < nextCode ? dict[code] : void 0;
+		if (!entry) {
+			entry = new Uint8Array(prevEntry.length + 1);
+			entry.set(prevEntry);
+			entry[prevEntry.length] = prevEntry[0];
+		}
+		if (!emit(entry)) break;
+		if (nextCode < 4096) {
+			const added = new Uint8Array(prevEntry.length + 1);
+			added.set(prevEntry);
+			added[prevEntry.length] = entry[0];
+			dict[nextCode++] = added;
+			if (nextCode + earlyChange === 512) codeLength = 10;
+			else if (nextCode + earlyChange === 1024) codeLength = 11;
+			else if (nextCode + earlyChange === 2048) codeLength = 12;
+		}
+		prev = code;
+	}
+	return out.subarray(0, outLen);
+}
+//#endregion
+export { lzwDecodeMsb };

package/dist/esm/core/metafile/emf.d.ts

@@ -0,0 +1,16 @@
+import { PathSegment } from '../vector.js';
+import { MetaPicture } from './picture.js';
+/** Whether the bytes open with an EMF header (MS-EMF §2.3.4.2: type 1 + " EMF"). */
+export declare function isEmf(bytes: Uint8Array): boolean;
+/**
+ * Read an EMF into its primitives.
+ *
+ * @throws Error when the bytes are not an EMF or its header is malformed.
+ */
+export declare function readEmf(bytes: Uint8Array): MetaPicture;
+type Mapper = (x: number, y: number) => {
+    x: number;
+    y: number;
+};
+export declare function ellipseSegments(map: Mapper, l: number, t: number, r: number, b: number): Array<PathSegment>;
+export {};