reamkit 1.30.0 → 1.32.0

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

@@ -148,6 +148,25 @@ var DEFAULT_THEME_PALETTE = new Map([
 	["hlink", "0563C1"],
 	["folHlink", "954F72"]
 ]);
+/**
+* The Office 2023 theme's palette — what Excel colours a workbook that carries
+* no theme part with. Its own PDF of theme slots 0…9 in such a workbook
+* (2026-10-01) paints exactly these: accent1 is 156082, not 2013's 4472C4.
+*/
+var OFFICE_2023_THEME_PALETTE = new Map([
+	["dk1", "000000"],
+	["lt1", "FFFFFF"],
+	["dk2", "0E2841"],
+	["lt2", "E8E8E8"],
+	["accent1", "156082"],
+	["accent2", "E97132"],
+	["accent3", "196B24"],
+	["accent4", "0F9ED5"],
+	["accent5", "A02B93"],
+	["accent6", "4EA72E"],
+	["hlink", "467886"],
+	["folHlink", "96607D"]
+]);
 var DEFAULT_SCHEME_ALIAS = {
 	tx1: "dk1",
 	bg1: "lt1",
@@ -284,8 +303,9 @@ var SYSTEM_COLORS = new Map([
 function resolveColorNode(c, resolveColor) {
 	if (poIs(c, "a:sysClr")) {
 		const last = poAttr(c, "lastClr");
-		if (last && /^[0-9A-Fa-f]{6}$/.test(last)) return last.toUpperCase();
-		return SYSTEM_COLORS.get(poAttr(c, "val") ?? "");
+		const hex = last && /^[0-9A-Fa-f]{6}$/.test(last) ? last.toUpperCase() : SYSTEM_COLORS.get(poAttr(c, "val") ?? "");
+		const sysMods = readColorMods(c);
+		return hex !== void 0 && sysMods.length > 0 ? applyColorMods(hex, sysMods) : hex;
 	}
 	if (poIs(c, "a:prstClr")) {
 		const hex = PRESET_COLORS.get((poAttr(c, "val") ?? "").toLowerCase());
@@ -305,4 +325,4 @@ function resolveColorNode(c, resolveColor) {
 	} : raw);
 }
 //#endregion
-export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, applyColorMods, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode };
+export { DEFAULT_SCHEME_ALIAS, DEFAULT_THEME_PALETTE, OFFICE_2023_THEME_PALETTE, defaultColorResolver, makeColorResolver, placeholderColors, readColorMods, resolveColorNode };

package/dist/esm/core/drawingml/shape-render.d.ts

@@ -30,7 +30,9 @@ export declare function gradientToSolid(gradient: ShapeGradient): string;
  * An SVG `<linearGradient>` / `<radialGradient>` definition for a gradient fill
  * (EP16), shared by the SVG and HTML writers. The linear vector is expressed in
  * `objectBoundingBox` space; the angle is negated because the shape's own path
- * transform flips y (local y-up → page y-down).
+ * transform flips y (local y-up → page y-down) — and a radial centre, given in
+ * fractions down from the box's top, is measured up from its bottom for the
+ * same reason.
  *
  * @param id The gradient element id (referenced by `fill="url(#id)"`).
  * @param g  The gradient fill.

package/dist/esm/core/drawingml/shape-render.js

@@ -51,7 +51,9 @@ function gradientToSolid(gradient) {
 * An SVG `<linearGradient>` / `<radialGradient>` definition for a gradient fill
 * (EP16), shared by the SVG and HTML writers. The linear vector is expressed in
 * `objectBoundingBox` space; the angle is negated because the shape's own path
-* transform flips y (local y-up → page y-down).
+* transform flips y (local y-up → page y-down) — and a radial centre, given in
+* fractions down from the box's top, is measured up from its bottom for the
+* same reason.
 *
 * @param id The gradient element id (referenced by `fill="url(#id)"`).
 * @param g  The gradient fill.
@@ -64,7 +66,7 @@ function gradientSvgDef(id, g) {
 		const c = g.center;
 		if (!c) return `<radialGradient id="${id}">${stops}</radialGradient>`;
 		const r = Math.SQRT2 / 2;
-		return `<radialGradient id="${id}" cx="${n(c.x)}" cy="${n(c.y)}" r="${n(r)}">${stops}</radialGradient>`;
+		return `<radialGradient id="${id}" cx="${n(c.x)}" cy="${n(1 - c.y)}" r="${n(r)}">${stops}</radialGradient>`;
 	}
 	const rad = -(g.angle ?? 0) * Math.PI / 180;
 	const dx = Math.cos(rad) / 2;

package/dist/esm/core/font/index.d.ts

@@ -9,3 +9,5 @@ export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';
 export { hasSubstitutable, lettersForLigature, substituteLetters } from './ligatures.js';
 export { createFontMeasure } from './measure.js';
 export type { FontMeasure } from './measure.js';
+export { buildTrueType, editableEmbedding, MAX_BUILT_GLYPHS } from './ttf-build.js';
+export type { BuiltFace, BuiltGlyph, BuiltKernPair, BuiltLigature, GlyphSeg, } from './ttf-build.js';

package/dist/esm/core/font/measure.d.ts

@@ -29,6 +29,15 @@ export interface FontMeasure {
      * `[…] TJ` array when shaping moved a glyph off its own advance.
      */
     readonly showText: (text: string) => string;
+    /**
+     * The glyphs `text` is drawn with and the advance each one takes, in font
+     * units — exactly what {@link showText} shows, kerning and ligatures
+     * included — for a writer that places each glyph itself.
+     */
+    readonly glyphRun: (text: string) => {
+        readonly gids: ReadonlyArray<number>;
+        readonly advances: ReadonlyArray<number>;
+    };
 }
 /**
  * Build a {@link FontMeasure} over a parsed font.

package/dist/esm/core/font/measure.js

@@ -52,6 +52,13 @@ function createFontMeasure(parsed, kern = true) {
 		if (hex !== "") parts.push(`<${hex}>`);
 		return `[${parts.join(" ")}] TJ`;
 	};
+	const glyphRun = (text) => {
+		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		return {
+			gids: shaped.gids,
+			advances: shaped.advances
+		};
+	};
 	const glyf = parsed.tables.get("glyf");
 	const glyphInk = (gid) => {
 		if (!glyf || gid < 0 || gid >= parsed.numGlyphs) return void 0;
@@ -92,7 +99,8 @@ function createFontMeasure(parsed, kern = true) {
 		textWidthPt,
 		textInkPt,
 		encodeTextAsCidHex,
-		showText
+		showText,
+		glyphRun
 	};
 }
 //#endregion

package/dist/esm/core/font/ttf-build.d.ts

@@ -0,0 +1,113 @@
+/** One piece of a glyph's outline, in a one-unit em with y up. */
+export type GlyphSeg = {
+    readonly op: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'close';
+};
+/** One glyph of a {@link BuiltFace}. */
+export interface BuiltGlyph {
+    /** The characters that select it, as code points. */
+    readonly codePoints: ReadonlyArray<number>;
+    /** Its contours, filled by the nonzero rule; empty for a blank glyph. */
+    readonly outline: ReadonlyArray<GlyphSeg>;
+    /** How far the pen moves after it, in thousandths of an em. */
+    readonly advance: number;
+}
+/** Everything {@link buildTrueType} needs to know about the face it builds. */
+export interface BuiltFace {
+    /** The family the font is installed under (`name` ID 1). */
+    readonly family: string;
+    /** The style within the family: its bold and italic slot (`name` ID 2). */
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** The PostScript name (`name` ID 6); only its printable ASCII is kept. */
+    readonly postScriptName: string;
+    readonly glyphs: ReadonlyArray<BuiltGlyph>;
+    /** Above and below the baseline, in thousandths of an em — `descent` negative. */
+    readonly ascent: number;
+    readonly descent: number;
+    readonly capHeight?: number;
+    readonly xHeight?: number;
+    /** Degrees counterclockwise from the vertical; a face slanted right is negative. */
+    readonly italicAngle?: number;
+    readonly fixedPitch?: boolean;
+    /**
+     * OS/2 `fsType` — the embedding the face's licence allows, carried over from
+     * the program the outlines came from.
+     */
+    readonly fsType: number;
+    /** The pairs the face is kerned by: how far the second glyph moves in towards the first. */
+    readonly kerning?: ReadonlyArray<BuiltKernPair>;
+    /** The glyphs the face draws for a run of characters at once: its ligatures. */
+    readonly ligatures?: ReadonlyArray<BuiltLigature>;
+}
+/**
+ * One ligature of a {@link BuiltFace}: a glyph no character reaches alone,
+ * substituted for the characters it joins wherever they meet (GSUB `liga`).
+ */
+export interface BuiltLigature {
+    /** The characters it stands for, in order — two or more. */
+    readonly codePoints: ReadonlyArray<number>;
+    readonly outline: ReadonlyArray<GlyphSeg>;
+    /** How far the pen moves after it, in thousandths of an em. */
+    readonly advance: number;
+}
+/** One kerning pair of a {@link BuiltFace}, by the characters it joins. */
+export interface BuiltKernPair {
+    /** The code point of the glyph on the left, and of the one after it. */
+    readonly left: number;
+    readonly right: number;
+    /** The adjustment to the left glyph's advance, in thousandths of an em — negative tightens. */
+    readonly value: number;
+}
+/**
+ * Whether a face's licence lets it be embedded, as outlines and subset, in a
+ * document that stays EDITABLE: OS/2 `fsType` states installable embedding (no
+ * usage bit) or grants editable embedding, and neither forbids subsetting nor
+ * allows bitmaps only. Restricted-licence and preview-and-print faces are
+ * refused — the second may travel only in a document opened read-only.
+ *
+ * Several usage bits at once is an old font's way of stating permissions, and
+ * the least restrictive of them applies (OS/2 versions 0–2).
+ *
+ * @param fsType The field, or `undefined` where the program states none —
+ *               which restricts nothing.
+ * @returns Whether an editable document may carry the face.
+ */
+export declare function editableEmbedding(fsType: number | undefined): boolean;
+/**
+ * The most glyphs a built face holds. A `cmap` format 4 subtable is limited to
+ * 64 KB, and past this many characters it may not fit; a face that large is a
+ * whole CJK font, which is no subset.
+ */
+export declare const MAX_BUILT_GLYPHS = 8000;
+/**
+ * Build a TrueType font from outlines (ISO/IEC 14496-22): `.notdef` first, then
+ * one glyph per {@link BuiltGlyph} in the order given, reachable through a
+ * Unicode `cmap`.
+ *
+ * Cubic curves become quadratic ones. A cubic that is a raised quadratic — what
+ * a TrueType source's outline arrives as — comes back as exactly that
+ * quadratic; any other is cut into as many quadratics as keep within half a
+ * unit of it. Each glyph's contours are turned to run clockwise round their
+ * ink, as TrueType's are.
+ *
+ * @param face The face: its names, metrics, licence and glyphs.
+ * @returns The font program's bytes.
+ * @throws When the face holds more than {@link MAX_BUILT_GLYPHS} glyphs.
+ */
+export declare function buildTrueType(face: BuiltFace): Uint8Array;