reamkit 1.21.0 → 1.23.0

package/dist/esm/pdf-reader/image-decode.js

@@ -1,8 +1,8 @@
 import { PDF_NULL, PdfHexString, PdfName, PdfStream } from "../pdf/objects.js";
 import { lzwDecodeMsb } from "../core/lzw.js";
+import { encodePng } from "../core/png-encode.js";
 import { reversePredictor } from "./predictor.js";
 import { decodeCcitt } from "./ccitt.js";
-import { encodePng } from "./png-encode.js";
 import { unzlibSync } from "fflate";
 //#region src/pdf-reader/image-decode.ts
 var MAX_PIXELS = 4e7;

package/dist/esm/pptx/embedded-fonts.d.ts

@@ -0,0 +1,31 @@
+import { Loss } from '../core/ir/index.js';
+import { OpcPackage } from '../core/opc/index.js';
+import { PoNode } from '../core/po-helpers.js';
+import { FontRegistry } from '../core/font/index.js';
+/** What an `fntdata` part turned out to hold. */
+type FaceBytes = {
+    readonly kind: 'font';
+    readonly bytes: Uint8Array;
+} | {
+    readonly kind: 'compressed';
+} | {
+    readonly kind: 'unreadable';
+};
+/**
+ * Read one `fntdata` part: the font itself when the container stores it
+ * plainly, and what stopped it otherwise.
+ *
+ * @param data The part's bytes.
+ */
+export declare function readFntData(data: Uint8Array): FaceBytes;
+/**
+ * §19.2.1.13 — the fonts a deck embeds, by normalized family name.
+ *
+ * @param pkg      The opened `.pptx` package.
+ * @param presPath The presentation part's path (relationships resolve from it).
+ * @param pres     Its parsed `p:presentation` element.
+ * @param onLoss   Where a face that cannot be unpacked records itself.
+ * @returns The families whose faces were readable (empty when none were).
+ */
+export declare function loadPptxEmbeddedFonts(pkg: OpcPackage, presPath: string, pres: PoNode | undefined, onLoss: (loss: Loss) => void): Map<string, FontRegistry>;
+export {};

package/dist/esm/pptx/embedded-fonts.js

@@ -0,0 +1,104 @@
+import { FontRegistry } from "../core/font/font-registry.js";
+import { poAttr, poChildren, poIs } from "../core/po-helpers.js";
+//#region src/pptx/embedded-fonts.ts
+var REL_FONT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+/** §19.2.1.13 — the four faces a `p:embeddedFont` may name, by element. */
+var VARIANTS = [
+	["p:regular", "regular"],
+	["p:bold", "bold"],
+	["p:italic", "italic"],
+	["p:boldItalic", "boldItalic"]
+];
+var EOT_VERSIONS = new Set([
+	65536,
+	131073,
+	131074
+]);
+var TTEMBED_TTCOMPRESSED = 4;
+var TTEMBED_XORENCRYPTDATA = 268435456;
+/**
+* Read one `fntdata` part: the font itself when the container stores it
+* plainly, and what stopped it otherwise.
+*
+* @param data The part's bytes.
+*/
+function readFntData(data) {
+	if (isSfnt(data)) return {
+		kind: "font",
+		bytes: data
+	};
+	if (data.length < 82) return { kind: "unreadable" };
+	const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	const eotSize = v.getUint32(0, true);
+	const version = v.getUint32(8, true);
+	const flags = v.getUint32(12, true);
+	if (eotSize !== data.length || !EOT_VERSIONS.has(version)) return { kind: "unreadable" };
+	if ((flags & (TTEMBED_TTCOMPRESSED | TTEMBED_XORENCRYPTDATA)) !== 0) return { kind: "compressed" };
+	let at = 82;
+	for (let i = 0; i < 4; i++) {
+		if (at + 2 > data.length) return { kind: "unreadable" };
+		at += 2 + v.getUint16(at, true) + 2;
+	}
+	if (version !== 65536) {
+		if (at + 2 > data.length) return { kind: "unreadable" };
+		at += 2 + v.getUint16(at, true);
+		at = data.length - v.getUint32(4, true);
+	}
+	const bytes = data.subarray(at);
+	return isSfnt(bytes) ? {
+		kind: "font",
+		bytes
+	} : { kind: "unreadable" };
+}
+/**
+* §19.2.1.13 — the fonts a deck embeds, by normalized family name.
+*
+* @param pkg      The opened `.pptx` package.
+* @param presPath The presentation part's path (relationships resolve from it).
+* @param pres     Its parsed `p:presentation` element.
+* @param onLoss   Where a face that cannot be unpacked records itself.
+* @returns The families whose faces were readable (empty when none were).
+*/
+function loadPptxEmbeddedFonts(pkg, presPath, pres, onLoss) {
+	const out = /* @__PURE__ */ new Map();
+	const list = pres ? poChildren(pres).find((c) => poIs(c, "p:embeddedFontLst")) : void 0;
+	if (!list) return out;
+	const relById = new Map(pkg.getPartRelationships(presPath).map((r) => [r.id, r]));
+	for (const font of poChildren(list).filter((c) => poIs(c, "p:embeddedFont"))) {
+		const bytes = {};
+		let compressed = false;
+		for (const [tag, variant] of VARIANTS) {
+			const node = poChildren(font).find((c) => poIs(c, tag));
+			const rId = node ? poAttr(node, "r:id") : void 0;
+			const rel = rId !== void 0 ? relById.get(rId) : void 0;
+			if (!rel || rel.type !== REL_FONT) continue;
+			const part = pkg.resolveRelatedPart(presPath, rel);
+			if (!part) continue;
+			const face = readFntData(part.data);
+			if (face.kind === "compressed") compressed = true;
+			if (face.kind === "font") bytes[variant] = face.bytes;
+		}
+		const typeface = poChildren(font).find((c) => poIs(c, "p:font"));
+		const name = (typeface ? poAttr(typeface, "typeface") : void 0)?.trim() ?? "";
+		if (bytes.regular) try {
+			out.set(name.toLowerCase(), FontRegistry.fromBytes({
+				...bytes,
+				regular: bytes.regular
+			}));
+			continue;
+		} catch {}
+		if (compressed) onLoss({
+			feature: "font",
+			detail: `the deck embeds ${name || "a font"}, packed with MicroType Express (EOT TTEMBED_TTCOMPRESSED); it renders in a substitute`,
+			severity: "substituted"
+		});
+	}
+	return out;
+}
+function isSfnt(data) {
+	if (data.length < 4) return false;
+	const sig = (data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]) >>> 0;
+	return sig === 65536 || sig === 1330926671 || sig === 1953658213 || sig === 1953784678;
+}
+//#endregion
+export { loadPptxEmbeddedFonts };

package/dist/esm/pptx/ole-preview.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shape id → the relationship id of its `v:imagedata`, for every shape in a
+ * legacy VML drawing part that has one.
+ *
+ * @param data The raw `vmlDrawing#.vml` bytes.
+ * @returns The map, keyed by shape id with the `_x0000_s` prefix stripped.
+ */
+export declare function parseVmlImageRels(data: Uint8Array): Map<string, string>;
+/** Strip the `_x0000_s` prefix a VML shape id carries, so both spellings meet. */
+export declare function normalizeSpid(id: string): string;

package/dist/esm/pptx/ole-preview.js

@@ -0,0 +1,52 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/pptx/ole-preview.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	removeNSPrefix: true
+});
+var SPID_PREFIX = /^_x0000_s/u;
+/**
+* Shape id → the relationship id of its `v:imagedata`, for every shape in a
+* legacy VML drawing part that has one.
+*
+* @param data The raw `vmlDrawing#.vml` bytes.
+* @returns The map, keyed by shape id with the `_x0000_s` prefix stripped.
+*/
+function parseVmlImageRels(data) {
+	const out = /* @__PURE__ */ new Map();
+	walk(parser.parse(decoder.decode(data)), out);
+	return out;
+}
+/** Strip the `_x0000_s` prefix a VML shape id carries, so both spellings meet. */
+function normalizeSpid(id) {
+	return id.replace(SPID_PREFIX, "");
+}
+function walk(node, out) {
+	if (node === null || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node) walk(item, out);
+		return;
+	}
+	const rec = node;
+	const shape = rec["shape"];
+	if (shape !== void 0) for (const s of Array.isArray(shape) ? shape : [shape]) collect(s, out);
+	for (const value of Object.values(rec)) walk(value, out);
+}
+function collect(shape, out) {
+	if (shape === null || typeof shape !== "object") return;
+	const rec = shape;
+	const id = rec["@_id"];
+	const imagedata = rec["imagedata"];
+	if (typeof id !== "string" || imagedata === void 0) return;
+	const first = Array.isArray(imagedata) ? imagedata[0] : imagedata;
+	if (first === null || typeof first !== "object") return;
+	const img = first;
+	const rel = img["@_relid"] ?? img["@_id"];
+	if (typeof rel === "string") out.set(normalizeSpid(id), rel);
+}
+//#endregion
+export { normalizeSpid, parseVmlImageRels };

package/dist/esm/pptx/placeholder-cascade.d.ts

@@ -1,7 +1,9 @@
-import { RunProperties } from '../core/document-model/index.js';
+import { ParagraphProperties, RunProperties } from '../core/document-model/index.js';
 import { ColorResolver } from '../core/drawingml/colors.js';
+import { ThemeFonts } from '../core/drawingml/theme-parser.js';
 import { PoNode } from '../core/po-helpers.js';
 import { PlaceholderRef, ShapeBoxEmu } from './sp-helpers.js';
+import { Pt } from '../core/ir/index.js';
 /**
  * The placeholder cascade (PX2): the resolver a slide parser consults whenever a
  * slide placeholder shape (`p:sp` with a `p:ph`) lacks its own geometry or run
@@ -12,11 +14,78 @@ export interface PlaceholderCascade {
     /** The inherited EMU box for a slide placeholder without its own `a:xfrm`. */
     readonly geometryFor: (ph: PlaceholderRef) => ShapeBoxEmu | undefined;
     /**
-     * The master's default run formatting for a placeholder's paragraph at the
-     * given 0-based outline level (empty when no master text styles apply).
+     * The inherited run formatting for a paragraph at the given 0-based outline
+     * level. Without a placeholder this is the presentation's default text style
+     * — what an ordinary text box on a slide is written in.
      */
-    readonly defaultsFor: (ph: PlaceholderRef, level: number) => RunProperties;
+    readonly defaultsFor: (ph: PlaceholderRef | undefined, level: number) => RunProperties;
+    /** The inherited paragraph shape at that level: alignment, indent, spacing. */
+    readonly paragraphDefaultsFor: (ph: PlaceholderRef | undefined, level: number) => ParagraphProperties;
+    /** The bullet that level inherits, which a paragraph states only to change. */
+    readonly bulletFor: (ph: PlaceholderRef | undefined, level: number) => LevelBullet | undefined;
+    /**
+     * The vertical anchor the placeholder's prototype states (`a:bodyPr@anchor`),
+     * the layout's before the master's, for a shape that states none itself.
+     */
+    readonly anchorFor: (ph: PlaceholderRef) => 't' | 'ctr' | 'b' | undefined;
+    /**
+     * The prototypes' own `p:spPr`, nearest first — the layout's, then the
+     * master's — for the properties a slide placeholder inherits rather than
+     * states: its fill, its outline, its geometry.
+     *
+     * A CHAIN and not one node, because the inheritance is per property. The
+     * layout's prototype may state a box and nothing else, and the fill then
+     * comes from the master: tdf104015's title is red in every reader and was a
+     * bare outline here, because the layout's `p:spPr` existed and stopped the
+     * search.
+     */
+    readonly shapePropsFor: (ph: PlaceholderRef) => ReadonlyArray<PoNode>;
+}
+/** One level of a text style: how its paragraphs sit and how their runs read. */
+interface LevelStyle {
+    readonly run: RunProperties;
+    readonly paragraph: ParagraphProperties;
+    readonly bullet?: LevelBullet;
+    /**
+     * §21.1.2.2.9/.10 — the space around the paragraph stated as a FRACTION of a
+     * line rather than a distance. A fraction of WHAT is only known once the
+     * levels have merged and the size is settled, so it travels this far raw.
+     */
+    readonly spacingPct?: {
+        readonly before?: number;
+        readonly after?: number;
+    };
 }
+/**
+ * §21.1.2.4.4/.5/.6 — the bullet a level declares: none at all, a literal
+ * character, or a number that counts. A slide paragraph states one only where
+ * it differs from this: themes.pptx's second slide writes one bare line, and
+ * the dot in front of it is the master's body style, nine levels up.
+ */
+export interface LevelBullet {
+    /** What it draws: nothing at all, a character, or a number that counts. */
+    readonly kind?: 'none' | 'char' | 'autoNum';
+    /** `a:buChar` — the character, already read out of the face that states it. */
+    readonly char?: string;
+    /** `a:buAutoNum @type`/`@startAt` — the numbering and where it starts. */
+    readonly type?: string;
+    readonly startAt?: number;
+    /** §21.1.2.4.2/.3 — its size, as a fraction of the text or in points. */
+    readonly sizePct?: number;
+    readonly sizePts?: number;
+    /** §21.1.2.4.1 `a:buClr` — the colour it is drawn in, when it has its own. */
+    readonly colorHex?: string;
+}
+/**
+ * What an `a:pPr` (or an `a:lvlNpPr`, the same vocabulary) says about its
+ * bullet — each part on its own, because a paragraph may restate the SIZE and
+ * leave the character to its level.
+ *
+ * @param pPr    The paragraph-properties node.
+ * @param colors The colour resolver, for `a:buClr`.
+ * @returns What it states, or `undefined` when it says nothing about bullets.
+ */
+export declare function parseBullet(pPr: PoNode | undefined, colors?: ColorResolver): LevelBullet | undefined;
 /**
  * Build a {@link PlaceholderCascade} from a slide's already-parsed layout and
  * master trees: it resolves a placeholder's inherited geometry (the layout's
@@ -26,5 +95,67 @@ export interface PlaceholderCascade {
  * @param layoutTree The parsed `p:sldLayout` part.
  * @param masterTree The parsed `p:sldMaster` part, when present.
  * @param colors     The deck's colour resolver, for scheme colours in the text styles.
+ * @param deckDefaults The presentation's own default text style, as the floor.
+ * @param themeFonts The theme's font scheme, for the `+mn-lt` tokens.
+ */
+export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver, deckDefaults?: ReadonlyArray<LevelStyle>, themeFonts?: ThemeFonts): PlaceholderCascade;
+/**
+ * §21.1.2.2.9/.10 — the space a paragraph states as a FRACTION of a line, in
+ * points.
+ *
+ * A "line" here is the paragraph's own text at its natural height, which is the
+ * size times the same 1.2 the layout gives an unstated line. A level that
+ * states the fraction and leaves the size to another level is resolved once
+ * they have merged, which is why this is not read where the fraction is.
+ *
+ * @param pct      The fraction, `0..n` (20% arrives as 0.2).
+ * @param sizePt   The paragraph's resolved font size.
+ * @returns The distance, or `undefined` when the size is not known.
+ */
+export declare function spacingFromLineFraction(pct: number | undefined, sizePt: number | undefined): Pt | undefined;
+/**
+ * `a:lstStyle` (or a `p:txStyles` family) → its nine levels. Shared by the
+ * deck's default text style, the master's families and a prototype's own list,
+ * which are the same vocabulary written in different places.
+ *
+ * @param list   The `a:lstStyle` / `p:titleStyle` / … node.
+ * @param colors The deck's colour resolver.
+ * @param prefix The level element prefix: `a:lvl` here, always.
+ * @returns The nine levels, or an empty list when there is no such node.
+ */
+export declare function parseLevelStyles(list: PoNode | undefined, colors: ColorResolver, themeFonts?: ThemeFonts): Array<LevelStyle>;
+/**
+ * A level's paragraph shape — §21.1.2.2.7 `@algn`, `@marL`/`@indent`, and the
+ * space around and between its lines.
+ *
+ * Both spacings come in two spellings: `a:spcPts` is a distance (hundredths of
+ * a point) and `a:spcPct` a FRACTION of a line (thousandths of a percent). Only
+ * the distance was read, so a deck that spaces its bullets the usual way — by
+ * fraction — set them solid.
+ */
+export declare function pPrToParagraphProps(lvlPr: PoNode | undefined): ParagraphProperties;
+/**
+ * §21.1.2.2.5 `a:lnSpc` — the height of each line: a fraction of the natural
+ * one (`a:spcPct`) or a distance (`a:spcPts`).
+ *
+ * The model states a multiple the way §17.3.1.33 does — 12pt under the `auto`
+ * rule IS single — so a fraction needs no font size to express, which is why
+ * this resolves here and the paragraph SPACING has to wait for the size.
+ *
+ * @param pPr The paragraph properties (a level's or a paragraph's own).
+ * @returns The line spacing, or nothing when the node states none.
+ */
+export declare function lineSpacing(pPr: PoNode | undefined): ParagraphProperties;
+/**
+ * §21.1.2.2.9/.10 — the fraction of a line a paragraph puts before and after
+ * itself, when it states one. The distance form is read beside it; this is what
+ * the caller must still resolve against the size.
+ *
+ * @param pPr The paragraph properties.
+ * @returns The two fractions (`0..n`), each present only when stated.
  */
-export declare function buildPlaceholderCascade(layoutTree: ReadonlyArray<PoNode>, masterTree: ReadonlyArray<PoNode> | undefined, colors: ColorResolver): PlaceholderCascade;
+export declare function spacingFractions(pPr: PoNode | undefined): {
+    readonly before?: number;
+    readonly after?: number;
+} | undefined;
+export {};