reamkit 1.33.2 → 1.34.0

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

@@ -1,6 +1,155 @@
 import { shapeText } from "./opentype-layout.js";
+import { hasIndic, shapeIndic } from "./indic-shaper.js";
 //#region src/core/font/measure.ts
 var EMPTY_KERNING = /* @__PURE__ */ new Map();
+/** The most shaped words a face keeps; past it the cache starts over. */
+var SHAPED_CACHE = 4096;
+/**
+* The glyphs a face draws a string with, and for each glyph the Indic shaper
+* made out of several characters (a conjunct, a reph, a vowel sign's
+* contextual form), the text it stands for — which a PDF's /ToUnicode has to
+* name, since no character maps to it.
+*
+* @param parsed The face.
+* @param text   The text.
+* @returns The glyph ids, and the text of each glyph no character reaches.
+*/
+function shapeGlyphs(parsed, text) {
+	const run = hasIndic(text) ? shapeIndic(parsed, text) : void 0;
+	if (!run) return { gids: shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, parsed.kerning, parsed.joiningForms).gids };
+	return {
+		gids: run.gids,
+		glyphText: shapedGlyphText(parsed, text, run)
+	};
+}
+/** The characters a face's cmap gives each glyph, scanned as /ToUnicode scans them: U+0009 to U+FFFF. */
+var cmapNames = /* @__PURE__ */ new WeakMap();
+function namesOf(parsed) {
+	let names = cmapNames.get(parsed);
+	if (!names) {
+		const map = /* @__PURE__ */ new Map();
+		for (let cp = 9; cp <= 65535; cp++) {
+			if (cp >= 55296 && cp <= 57343) continue;
+			const gid = parsed.glyphForCodepoint(cp);
+			if (gid === 0) continue;
+			const had = map.get(gid);
+			if (had) had.push(cp);
+			else map.set(gid, [cp]);
+		}
+		names = map;
+		cmapNames.set(parsed, names);
+	}
+	return names;
+}
+/** A character's canonical parts: क़ is क and the nukta, ো is ে and া. */
+var partsOf = (cp) => [...String.fromCodePoint(cp).normalize("NFD")].map((ch) => ch.codePointAt(0));
+var IGNORABLE_RE = /\p{Default_Ignorable_Code_Point}/u;
+/**
+* Each glyph the shaper made that no character maps to, with the characters
+* it was made from, in the order they were written: the reph of पार्श्व
+* stands for र्, the conjunct it rides on for श्व, the short i of हि for ि.
+* Each pair is one cluster, and a glyph given the cluster's text less what
+* its other glyphs are named after read the tail of पार्श्व twice: once for
+* the conjunct and once for the reph.
+*
+* A cluster is read glyph by glyph:
+* - A glyph a character maps to is named after it by /ToUnicode, and reads
+*   that much of what it was made from — or, where a face moved a glyph by
+*   swapping two (Noto Sans Bengali sets a reph after a vowel sign so), of
+*   the rest of its cluster.
+* - A made glyph reads what is left of the characters it was made from. Of a
+*   character drawn in several, each takes a part: a two-part vowel sign
+*   whose first part joined the consonant stands there for its first part,
+*   and the glyph of the second part for the second.
+* - What is left of the cluster goes to a made glyph that read nothing, or
+*   else to the one after the glyph it was drawn as: the o of कों is set as
+*   the glyph of the aa, its top in the anusvara's, and the anusvara stands
+*   for both. Left out, a reader lost the o of a plural.
+* - A made glyph that still reads nothing — one of the pieces a face draws a
+*   letter in — stands for its letter, so that every glyph drawn reads.
+*/
+function shapedGlyphText(parsed, text, run) {
+	const cps = [...text].map((ch) => ch.codePointAt(0));
+	const names = namesOf(parsed);
+	const made = run.gids.map((gid) => gid !== 0 && !names.has(gid));
+	const starts = [...new Set(run.clusters)].sort((a, b) => a - b);
+	const members = /* @__PURE__ */ new Map();
+	const clusterOf = [];
+	starts.forEach((c, k) => {
+		const all = [];
+		for (let s = k === 0 ? 0 : c; s < (starts[k + 1] ?? cps.length); s++) {
+			all.push(s);
+			clusterOf[s] = c;
+		}
+		members.set(c, all);
+	});
+	const carriers = cps.map(() => []);
+	const madeIn = /* @__PURE__ */ new Map();
+	run.sources.forEach((own, i) => {
+		for (const s of own) carriers[s]?.push(i);
+		if (!made[i]) return;
+		const had = madeIn.get(run.clusters[i]);
+		if (had) had.push(i);
+		else madeIn.set(run.clusters[i], [i]);
+	});
+	const unread = cps.map(partsOf);
+	const take = (parts, from, late) => {
+		const pool = from.map((s) => [...unread[s]]);
+		for (const part of parts) {
+			let q = -1;
+			pool.forEach((have, at) => {
+				if (have.includes(part) && (q < 0 || late)) q = at;
+			});
+			if (q < 0) return false;
+			pool[q].splice(pool[q].indexOf(part), 1);
+		}
+		from.forEach((s, at) => unread[s] = pool[at]);
+		return true;
+	};
+	const madeFrom = /* @__PURE__ */ new Set();
+	run.gids.forEach((gid, j) => {
+		const own = run.sources[j];
+		if (made[j]) for (const s of own) madeFrom.add(s);
+		const said = names.get(gid);
+		if (!said) return;
+		const late = own.some((s) => madeFrom.has(s));
+		if (said.some((name) => take(partsOf(name), own, late))) return;
+		const others = (members.get(run.clusters[j]) ?? []).filter((s) => !own.includes(s));
+		if (said.some((name) => take(partsOf(name), others, late))) return;
+		if (own.length > 1 && !said.some((name) => IGNORABLE_RE.test(String.fromCodePoint(name)))) for (const s of own) unread[s] = [];
+	});
+	const pieces = run.gids.map(() => []);
+	const rest = (s) => {
+		const left = unread[s];
+		if (left.length === partsOf(cps[s]).length) return String.fromCodePoint(cps[s]);
+		return String.fromCodePoint(...left).normalize("NFC");
+	};
+	cps.forEach((_, s) => {
+		const left = unread[s];
+		const mine = carriers[s].filter((i) => made[i]);
+		if (left.length === 0 || mine.length === 0) return;
+		if (mine.length === 1) pieces[mine[0]].push([s, rest(s)]);
+		else mine.forEach((i, k) => {
+			const part = k === mine.length - 1 ? left.slice(k) : left.slice(k, k + 1);
+			if (part.length > 0) pieces[i].push([s, String.fromCodePoint(...part).normalize("NFC")]);
+		});
+		unread[s] = [];
+	});
+	cps.forEach((cp, s) => {
+		if (unread[s].length === 0 || IGNORABLE_RE.test(String.fromCodePoint(cp))) return;
+		const near = madeIn.get(clusterOf[s]) ?? [];
+		const after = carriers[s][0] ?? -1;
+		const to = near.find((i) => pieces[i].length === 0) ?? near.find((i) => i > after) ?? near.at(-1);
+		if (to !== void 0) pieces[to].push([s, rest(s)]);
+	});
+	const out = /* @__PURE__ */ new Map();
+	run.gids.forEach((gid, i) => {
+		if (!made[i] || out.has(gid)) return;
+		const said = [...pieces[i].length > 0 ? pieces[i] : run.sources[i].map((s) => [s, String.fromCodePoint(cps[s])])].sort((a, b) => a[0] - b[0]).map(([, t]) => t).join("");
+		if (said !== "") out.set(gid, said);
+	});
+	return out;
+}
 /**
 * Build a {@link FontMeasure} over a parsed font.
 *
@@ -21,20 +170,38 @@ function createFontMeasure(parsed, kern = true) {
 		if (gid < 0 || gid >= parsed.numGlyphs) return 1e3;
 		return widths[gid];
 	};
+	const indicRuns = /* @__PURE__ */ new Map();
+	const shape = (text) => {
+		if (hasIndic(text)) {
+			let run = indicRuns.get(text);
+			if (run === void 0) {
+				if (indicRuns.size >= SHAPED_CACHE) indicRuns.clear();
+				run = shapeIndic(parsed, text, kern) ?? null;
+				indicRuns.set(text, run);
+			}
+			if (run) return {
+				gids: run.gids,
+				advances: run.advances,
+				indic: run
+			};
+		}
+		return shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+	};
 	const textWidthPt = (text, fontSize) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		const shaped = shape(text);
 		let totalEm = 0;
 		for (const a of shaped.advances) totalEm += a;
 		return totalEm * fontSize / parsed.unitsPerEm;
 	};
 	const encodeTextAsCidHex = (text) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		const shaped = shape(text);
 		let out = "";
 		for (const gid of shaped.gids) out += gid.toString(16).padStart(4, "0").toUpperCase();
 		return out;
 	};
-	const showText = (text) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+	const showText = (text, fontSizePt, clusterSpacingPt, before) => {
+		const shaped = shape(text);
+		if (shaped.indic) return showPlaced(shaped.indic, fontSizePt, clusterSpacingPt ?? 0, before);
 		const parts = [];
 		let hex = "";
 		let kerned = false;
@@ -52,12 +219,80 @@ function createFontMeasure(parsed, kern = true) {
 		if (hex !== "") parts.push(`<${hex}>`);
 		return `[${parts.join(" ")}] TJ`;
 	};
+	const showPlaced = (run, fontSizePt, spacingPt, before) => {
+		const upem = parsed.unitsPerEm;
+		const ops = [];
+		let parts = [];
+		let hex = "";
+		let shift = 0;
+		let rise = 0;
+		const flushShift = () => {
+			if (shift === 0) return;
+			if (hex !== "") parts.push(`<${hex}>`);
+			hex = "";
+			parts.push(String(Number(shift.toFixed(2))));
+			shift = 0;
+		};
+		const flushShow = () => {
+			if (hex !== "") parts.push(`<${hex}>`);
+			hex = "";
+			if (parts.length === 1 && parts[0].startsWith("<")) ops.push(`${parts[0]} Tj`);
+			else if (parts.length > 0) ops.push(`[${parts.join(" ")}] TJ`);
+			parts = [];
+		};
+		const move = (units) => {
+			shift -= units * 1e3 / upem;
+		};
+		for (let i = 0; i < run.gids.length; i++) {
+			const gid = run.gids[i];
+			const dx = run.xOffsets[i] ?? 0;
+			const dy = fontSizePt === void 0 ? 0 : (run.yOffsets[i] ?? 0) * fontSizePt / upem;
+			const op = before?.get(i);
+			if (op !== void 0) {
+				flushShift();
+				flushShow();
+				ops.push(op);
+			}
+			if (dy !== rise) {
+				flushShift();
+				flushShow();
+				ops.push(`${String(Number(dy.toFixed(3)))} Ts`);
+				rise = dy;
+			}
+			move(dx);
+			flushShift();
+			hex += gid.toString(16).padStart(4, "0").toUpperCase();
+			move((run.advances[i] ?? 0) - (parsed.advanceWidths[gid] ?? 0) - dx);
+			if (run.clusters[i + 1] !== run.clusters[i] && spacingPt !== 0 && fontSizePt) shift -= spacingPt * 1e3 / fontSizePt;
+		}
+		flushShift();
+		flushShow();
+		if (rise !== 0) ops.push("0 Ts");
+		return ops.join(" ");
+	};
 	const glyphRun = (text) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
-		return {
+		const shaped = shape(text);
+		const run = shaped.indic;
+		if (!run) return {
 			gids: shaped.gids,
 			advances: shaped.advances
 		};
+		return {
+			gids: run.gids,
+			advances: run.advances,
+			xOffsets: run.xOffsets,
+			yOffsets: run.yOffsets,
+			clusterEnds: run.clusters.map((c, i) => run.clusters[i + 1] !== c)
+		};
+	};
+	const clustered = (text) => shape(text).indic !== void 0;
+	const glyphSources = (text) => {
+		const run = shape(text).indic;
+		return run?.sources.map((s, i) => s[0] ?? run.clusters[i]);
+	};
+	const spacingSlots = (text) => {
+		const run = shape(text).indic;
+		return run ? new Set(run.clusters).size : [...text].length;
 	};
 	const glyf = parsed.tables.get("glyf");
 	const glyphInk = (gid) => {
@@ -75,15 +310,16 @@ function createFontMeasure(parsed, kern = true) {
 		};
 	};
 	const textInkPt = (text, fontSize) => {
-		const shaped = shapeText(text, parsed.glyphForCodepoint, parsed.advanceWidths, parsed.ligatures, kerning, parsed.joiningForms);
+		const shaped = shape(text);
 		let yMax = -Infinity;
 		let yMin = Infinity;
-		for (const gid of shaped.gids) {
+		shaped.gids.forEach((gid, i) => {
 			const ink = glyphInk(gid);
-			if (!ink) continue;
-			if (ink.yMax > yMax) yMax = ink.yMax;
-			if (ink.yMin < yMin) yMin = ink.yMin;
-		}
+			if (!ink) return;
+			const dy = shaped.indic?.yOffsets[i] ?? 0;
+			if (ink.yMax + dy > yMax) yMax = ink.yMax + dy;
+			if (ink.yMin + dy < yMin) yMin = ink.yMin + dy;
+		});
 		if (!Number.isFinite(yMax) || !Number.isFinite(yMin)) {
 			yMax = parsed.capHeight || parsed.ascender;
 			yMin = 0;
@@ -100,8 +336,11 @@ function createFontMeasure(parsed, kern = true) {
 		textInkPt,
 		encodeTextAsCidHex,
 		showText,
-		glyphRun
+		glyphRun,
+		clustered,
+		glyphSources,
+		spacingSlots
 	};
 }
 //#endregion
-export { createFontMeasure };
+export { createFontMeasure, shapeGlyphs };

package/dist/esm/core/font/opentype-lookups.d.ts

@@ -0,0 +1,214 @@
+import { ParsedTtf } from './ttf-parser.js';
+/** One glyph in the buffer the lookups run over. */
+export interface OtlGlyph {
+    /** The glyph id. */
+    gid: number;
+    /** Index of the first character it was made from; a ligature takes the least. */
+    cluster: number;
+    /** The features that may act on it, one bit each (see {@link OtlStep.mask}). */
+    mask: number;
+    /** Its GDEF class: 0 unclassified, 1 base, 2 ligature, 3 mark, 4 component. */
+    cls: number;
+    /** The syllable it belongs to, or 0; a per-syllable lookup matches within one. */
+    syllable: number;
+    /** A join control, which a match may step over (see {@link OtlStep}). */
+    joiner?: 'zwj' | 'zwnj';
+    /** The ligature it is, or the ligature a mark inside it was skipped by; 0 none. */
+    ligId: number;
+    /** For a mark skipped inside a ligature: the component it followed, from 1. */
+    ligComp: number;
+    /**
+     * What substitution made it, as {@link SUBSTITUTED}, {@link LIGATED} and
+     * {@link MULTIPLIED} bits: a shaper asks whether a reph or a pre-base form
+     * actually formed. Absent ⇒ none.
+     */
+    props?: number;
+    /**
+     * The characters it stands for, as indices into the text, least first. A
+     * ligature stands for the characters of its components, and each glyph of
+     * a multiple substitution for those of the glyph it replaced; a reader of
+     * the page is told the text of a glyph no character maps to from this.
+     * Absent where the shaper does not keep it.
+     */
+    sources?: ReadonlyArray<number>;
+}
+/** {@link OtlGlyph.props}: a GSUB lookup replaced the glyph. */
+export declare const SUBSTITUTED = 1;
+/** {@link OtlGlyph.props}: …by a ligature, last of all. */
+export declare const LIGATED = 2;
+/** {@link OtlGlyph.props}: …by a multiple substitution, last of all. */
+export declare const MULTIPLIED = 4;
+/** Where a glyph is drawn, in font units: its advance, and its offset off the pen. */
+export interface OtlPosition {
+    xAdvance: number;
+    yAdvance: number;
+    xOffset: number;
+    yOffset: number;
+    /** The glyph it hangs on, as the distance to it in the buffer; 0 none. */
+    attachChain: number;
+    /** How it hangs there: 1 a mark on its anchor, 2 a cursive join. */
+    attachType: 0 | 1 | 2;
+}
+/** One lookup to run, with the glyphs it may act on and how it matches. */
+export interface OtlStep {
+    /** Its index in the table's LookupList. */
+    readonly lookup: number;
+    /** It acts on a glyph whose mask shares a bit with this one. */
+    readonly mask: number;
+    /** A ZWJ between the glyphs of a match is stepped over. */
+    readonly autoZwj: boolean;
+    /** A ZWNJ between the glyphs of a context is stepped over. */
+    readonly autoZwnj: boolean;
+    /** A match keeps to the syllable of the glyph it starts on. */
+    readonly perSyllable: boolean;
+}
+/** A feature a shaper asks for: its tag, and how its lookups are to run. */
+export interface OtlFeature {
+    readonly tag: string;
+    readonly mask: number;
+    /** The font's own rules decide what a ZWJ does, so a match does not skip it. */
+    readonly manualZwj?: boolean;
+    /** …and what a ZWNJ does. */
+    readonly manualZwnj?: boolean;
+    readonly perSyllable?: boolean;
+}
+interface LangSys {
+    readonly required: number;
+    readonly features: ReadonlyArray<number>;
+}
+interface Script {
+    readonly defaultLangSys?: LangSys;
+    readonly langSys: ReadonlyMap<string, LangSys>;
+}
+interface Lookup {
+    /** The type of its subtables, with an Extension unwrapped. */
+    readonly type: number;
+    readonly flag: number;
+    readonly markSet: number;
+    /** Absolute offsets of its subtables, an Extension's target in its place. */
+    readonly subtables: ReadonlyArray<number>;
+}
+/** A GSUB or GPOS table, read as far as its lists. */
+export interface LayoutTable {
+    readonly kind: 'GSUB' | 'GPOS';
+    readonly scripts: ReadonlyMap<string, Script>;
+    readonly features: ReadonlyArray<{
+        readonly tag: string;
+        readonly lookups: ReadonlyArray<number>;
+    }>;
+    readonly lookups: ReadonlyArray<Lookup>;
+}
+/**
+ * A face's layout tables, read once: GDEF's classes and the lists of GSUB and
+ * GPOS, with each coverage table and class definition read the first time a
+ * lookup asks for it.
+ */
+export declare class OtlFace {
+    readonly parsed: ParsedTtf;
+    private static readonly cache;
+    /** The face's GSUB, when it has one that reads. */
+    readonly gsub?: LayoutTable;
+    /** …and its GPOS. */
+    readonly gpos?: LayoutTable;
+    private readonly raw;
+    private readonly glyphClasses;
+    private readonly attachClasses;
+    private readonly markSets;
+    private readonly coverages;
+    private readonly classDefs;
+    private constructor();
+    /**
+     * The layout tables of a face, read on first use and kept with it.
+     *
+     * @param parsed The face.
+     * @returns Its {@link OtlFace}.
+     */
+    static of(parsed: ParsedTtf): OtlFace;
+    /** A glyph's GDEF class: 1 base, 2 ligature, 3 mark, 4 component, 0 none. */
+    glyphClass(gid: number): number;
+    /** A mark's attachment class, which a lookup's flag may select. */
+    attachClass(gid: number): number;
+    /** Whether a glyph is in one of GDEF's mark glyph sets. */
+    inMarkSet(set: number, gid: number): boolean;
+    /** @internal The coverage table at an absolute offset: glyph → coverage index. */
+    coverage(off: number): ReadonlyMap<number, number>;
+    /** @internal The class definition at an absolute offset: glyph → class, 0 unlisted. */
+    classDef(off: number): ReadonlyMap<number, number>;
+    /** @internal The raw bytes of the face. */
+    get bytes(): Uint8Array;
+    private readTable;
+}
+/**
+ * The script a table answers for, of the tags a shaper prefers: the first the
+ * table has, else its default script, else Latin.
+ *
+ * @param table      The GSUB or GPOS table.
+ * @param scriptTags The tags, most preferred first (`dev2`, then `deva`).
+ * @returns The tag found, or `undefined` when the table has none of them.
+ */
+export declare function pickScript(table: LayoutTable | undefined, scriptTags: ReadonlyArray<string>): string | undefined;
+/**
+ * The lookups a set of features runs, merged and in LookupList order — the
+ * order they apply in, whichever feature named them.
+ *
+ * A lookup two of the features name runs once, on the glyphs either feature
+ * may act on. The language system's required feature, if it has one, runs on
+ * every glyph.
+ *
+ * @param table      The GSUB or GPOS table.
+ * @param scriptTags The script tags to look for, most preferred first.
+ * @param features   The features, with the glyphs each acts on.
+ * @param language   A language system tag; the script's default otherwise.
+ * @returns The steps to run, in order.
+ */
+export declare function planLookups(table: LayoutTable | undefined, scriptTags: ReadonlyArray<string>, features: ReadonlyArray<OtlFeature>, language?: string): Array<OtlStep>;
+/**
+ * Run a stage of GSUB lookups over the buffer, each over the whole of it
+ * before the next begins.
+ *
+ * @param face  The face.
+ * @param steps The lookups, from {@link planLookups} over its GSUB.
+ * @param buf   The glyphs; substituted in place, and may grow or shrink.
+ */
+export declare function substitute<TGlyph extends OtlGlyph>(face: OtlFace, steps: ReadonlyArray<OtlStep>, buf: Array<TGlyph>): void;
+/**
+ * Position the buffer: each glyph's own advance, then a stage of GPOS lookups,
+ * then every mark and cursive join carried along with the glyph it hangs on.
+ *
+ * @param face  The face.
+ * @param steps The lookups, from {@link planLookups} over its GPOS.
+ * @param buf   The glyphs, after substitution.
+ * @returns A position per glyph, in font units, y up.
+ */
+export declare function position<TGlyph extends OtlGlyph>(face: OtlFace, steps: ReadonlyArray<OtlStep>, buf: Array<TGlyph>): Array<OtlPosition>;
+/**
+ * Whether a feature's lookups would substitute this exact sequence of glyphs
+ * — the question a shaper asks before it decides that a consonant takes its
+ * below-base form, or that a Ra starts a reph.
+ *
+ * @param face        The face.
+ * @param steps       The feature's lookups, from {@link planLookups}.
+ * @param gids        The glyphs, in order.
+ * @param zeroContext Only a rule with no backtrack and no lookahead counts.
+ * @returns `true` when one of them would.
+ */
+export declare function wouldSubstitute(face: OtlFace, steps: ReadonlyArray<OtlStep>, gids: ReadonlyArray<number>, zeroContext: boolean): boolean;
+/**
+ * Make `buf[start..end)` one cluster, the least of theirs. A cluster cut at
+ * either edge comes in whole, as HarfBuzz merges them: a vowel sign that was
+ * one cluster with the last letter of a conjunct is one with the conjunct.
+ *
+ * @param buf   The glyphs.
+ * @param start The first glyph of the stretch.
+ * @param end   The glyph after its last.
+ */
+export declare function mergeClusters(buf: Array<OtlGlyph>, start: number, end: number): void;
+/**
+ * The characters a run of glyphs stands for together, each once, least first;
+ * `undefined` when none of them keeps its characters.
+ *
+ * @param glyphs The glyphs.
+ * @returns Their sources, merged.
+ */
+export declare function joinSources(glyphs: ReadonlyArray<OtlGlyph>): ReadonlyArray<number> | undefined;
+export {};