@mark1russell7/typeset 0.1.2 → 0.1.3

package/build/chunks/font.d.ts

@@ -22,6 +22,15 @@ interface GlyphInfo {
   /** The code point of the character of the glyph, after the normalization. */
   readonly codePoint: number;
 }
+/** One substitution that a lookup can do, with no context. */
+interface SubstitutionRule {
+  /** The glyph that the rule replaces. The first glyph of a ligature is this glyph. */
+  readonly from: number;
+  /** The glyphs that replace it. A multiple substitution can give no glyph. */
+  readonly to: readonly number[];
+  /** The other glyphs of a ligature, in order. Another rule has no such glyphs. */
+  readonly components?: readonly number[];
+}
 /** A lookup of GSUB for one script and one set of features. */
 interface SubstitutionLookup {
   /** The index of the lookup in the lookup list of GSUB. */
@@ -49,6 +58,12 @@ interface SubstitutionLookup {
    * `hb_ot_layout_lookup_would_substitute` with zero context tells it. A context rule with backtrack or lookahead does not apply.
    */
   wouldApply(glyphs: readonly number[]): boolean;
+  /**
+   * This function gives the rules of the lookup, and the rules of each lookup that it nests in a context rule. Each lookup
+   * has one list, and the list of this lookup is the first. The lists do not tell a context, so each nested rule counts.
+   * An alternate substitution gives one rule for each alternate.
+   */
+  rules(): readonly (readonly SubstitutionRule[])[];
 }
 /** One axis of `fvar`, in the user units of the axis. */
 interface Axis {
@@ -80,6 +95,16 @@ interface PairLookup {
   readonly skip?: (glyph: number) => boolean;
   /** This function gives the value for a pair, or `undefined` when no subtable applies. */
   pair(first: number, second: number): PairValue | undefined;
+  /**
+   * This function gives the largest positive value of each glyph of a pair, over the pairs with two glyphs of `glyphs`.
+   * A value is at least 0. It uses the values of the instance, so it includes each variation delta.
+   */
+  largest(glyphs: ReadonlySet<number>): LargestKerning;
+}
+/** The largest positive kerning of the first glyph and of the second glyph of a pair, in font units. */
+interface LargestKerning {
+  readonly first: number;
+  readonly second: number;
 }
 /** The options of `readFont`. */
 interface ReadOptions {

package/build/chunks/font.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"font.d.ts","names":[],"sources":["../../src/fonts/substitution.ts","../../src/fonts/variations.ts","../../src/fonts/kerning.ts","../../src/fonts/font.ts"],"mappings":";;;;;cAQa;;;;;UA6CI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;WAES;;;UAIM;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;EAMT,MAAM,kBAAkB,kBAAkB;;;;;;EAM1C,WAAW,kBAAkB,OAAO,aAAa,cAAc;;;;;EAK/D,WAAW;;;UC3FI;WACN;WACA;WACA;WACA;;;KAIC,WAAW,SAAS;;UCLf;WACN;WACA;;WAEA;;WAEA;;WAEA;;;UAIM;WACN;;;;;WAKA,QAAQ;;EAEjB,KAAK,eAAe,iBAAiB;;;UCbtB;;WAEN,aAAa;;;;;WAKb,WAAW;;;;;WAKX;;;;;WAKA;;;;;WAKA;;;KAIC;;UAGK;;;;;WAKN;WACA;;WAEA,eAAe;;WAEf,UAAU;;WAEV;;WAEA,eAAe;WACf;;EAET,MAAM;;EAEN,QAAQ;;EAER,WAAW;;EAEX,QAAQ,0BAA0B;;EAElC,cAAc,gBAAgB,uCAAuC;;EAErE,GAAG,UAAU,WAAW;;;iBAIV,SAAS,OAAO,YAAY,UAAS,cAAmB;;UA8JvD;;WAEN;;;;;WAKA;;WAEA;;;;;;WAMA;;;;;;WAMA;;;;;WAKA;;;;;WAKA;;;;;WAKA;;;;;;iBAYK,aAAa;;;;;;;iBAgDb,cAAc,MAAM,MAAM,cAAc,UAAS;EAAwB;EAAkB;;;;;;iBAkG3F,aAAa,MAAM,MAAM,cAAc,cAAc,UAAS"}
+{"version":3,"file":"font.d.ts","names":[],"sources":["../../src/fonts/substitution.ts","../../src/fonts/variations.ts","../../src/fonts/kerning.ts","../../src/fonts/font.ts"],"mappings":";;;;;cAQa;;;;;UA6CI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;WAES;;;UAIM;;WAEN;;WAEA;;WAEA;;;UAIM;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;EAMT,MAAM,kBAAkB,kBAAkB;;;;;;EAM1C,WAAW,kBAAkB,OAAO,aAAa,cAAc;;;;;EAK/D,WAAW;;;;;;EAMX,4BAA4B;;;UC3Gb;WACN;WACA;WACA;WACA;;;KAIC,WAAW,SAAS;;UCLf;WACN;WACA;;WAEA;;WAEA;;WAEA;;;UAIM;WACN;;;;;WAKA,QAAQ;;EAEjB,KAAK,eAAe,iBAAiB;;;;;EAKrC,QAAQ,QAAQ,sBAAsB;;;UAIvB;WACN;WACA;;;UCxBM;;WAEN,aAAa;;;;;WAKb,WAAW;;;;;WAKX;;;;;WAKA;;;;;WAKA;;;KAIC;;UAGK;;;;;WAKN;WACA;;WAEA,eAAe;;WAEf,UAAU;;WAEV;;WAEA,eAAe;WACf;;EAET,MAAM;;EAEN,QAAQ;;EAER,WAAW;;EAEX,QAAQ,0BAA0B;;EAElC,cAAc,gBAAgB,uCAAuC;;EAErE,GAAG,UAAU,WAAW;;;iBAIV,SAAS,OAAO,YAAY,UAAS,cAAmB;;UA8JvD;;WAEN;;;;;WAKA;;WAEA;;;;;;WAMA;;;;;;WAMA;;;;;WAKA;;;;;WAKA;;;;;WAKA;;;;;;iBAYK,aAAa;;;;;;;iBAgEb,cAAc,MAAM,MAAM,cAAc,UAAS;EAAwB;EAAkB;;;;;;iBAkG3F,aAAa,MAAM,MAAM,cAAc,cAAc,UAAS"}

package/build/chunks/font.js

@@ -123,6 +123,27 @@ function coverageIndex(table, glyph) {
 	}
 	throw new Error(`the Coverage format ${format} is unknown`);
 }
+/** This function gives each glyph of a Coverage table with its coverage index, in the order of the table. */
+function coverageGlyphs(table) {
+	const format = table.u16(0);
+	const count = table.u16(2);
+	const glyphs = [];
+	if (format === 1) {
+		for (let k = 0; k < count; k++) glyphs.push([table.u16(4 + k * 2), k]);
+		return glyphs;
+	}
+	if (format === 2) {
+		for (let k = 0; k < count; k++) {
+			const at = 4 + k * 6;
+			const start = table.u16(at);
+			const end = table.u16(at + 2);
+			const index = table.u16(at + 4);
+			for (let glyph = start; glyph <= end; glyph++) glyphs.push([glyph, index + glyph - start]);
+		}
+		return glyphs;
+	}
+	throw new Error(`the Coverage format ${format} is unknown`);
+}
 /** The GDEF glyph classes: 1 base, 2 ligature, 3 mark, 4 component. */
 function readGlyphClasses(gdef) {
 	if (gdef === void 0) return () => 0;
@@ -168,7 +189,7 @@ function pairValue(first, second, skipSecond) {
 		skipSecond
 	};
 }
-/** This function makes the pair function of one PairPos subtable. */
+/** This function makes the functions of one PairPos subtable. */
 function pairSubtable(table, store) {
 	const format = table.u16(0);
 	const coverage = table.part(table.u16(2));
@@ -177,28 +198,53 @@ function pairSubtable(table, store) {
 	const size1 = valueSize(format1);
 	const size2 = valueSize(format2);
 	const skipSecond = format2 !== 0;
-	if (format === 1) return (first, second) => {
-		const index = coverageIndex(coverage, first);
-		if (index < 0) return void 0;
-		const set = table.part(table.u16(10 + index * 2));
+	if (format === 1) {
 		const recordSize = 2 + size1 + size2;
-		let low = 0;
-		let high = set.u16(0) - 1;
-		while (low <= high) {
-			const middle = low + high >> 1;
-			const at = 2 + middle * recordSize;
-			const glyph = set.u16(at);
-			if (second < glyph) high = middle - 1;
-			else if (second > glyph) low = middle + 1;
-			else return pairValue(xAdvance(set, at + 2, format1, set, store), xAdvance(set, at + 2 + size1, format2, set, store), skipSecond);
-		}
-	};
+		const pair = (first, second) => {
+			const index = coverageIndex(coverage, first);
+			if (index < 0) return void 0;
+			const set = table.part(table.u16(10 + index * 2));
+			let low = 0;
+			let high = set.u16(0) - 1;
+			while (low <= high) {
+				const middle = low + high >> 1;
+				const at = 2 + middle * recordSize;
+				const glyph = set.u16(at);
+				if (second < glyph) high = middle - 1;
+				else if (second > glyph) low = middle + 1;
+				else return pairValue(xAdvance(set, at + 2, format1, set, store), xAdvance(set, at + 2 + size1, format2, set, store), skipSecond);
+			}
+		};
+		const largest = (glyphs) => {
+			let first = 0;
+			let second = 0;
+			for (const glyph of glyphs) {
+				const index = coverageIndex(coverage, glyph);
+				if (index < 0) continue;
+				const set = table.part(table.u16(10 + index * 2));
+				for (let record = 0; record < set.u16(0); record++) {
+					const at = 2 + record * recordSize;
+					if (!glyphs.has(set.u16(at))) continue;
+					first = Math.max(first, xAdvance(set, at + 2, format1, set, store).value);
+					second = Math.max(second, xAdvance(set, at + 2 + size1, format2, set, store).value);
+				}
+			}
+			return {
+				first,
+				second
+			};
+		};
+		return {
+			pair,
+			largest
+		};
+	}
 	if (format === 2) {
 		const classes1 = table.part(table.u16(8));
 		const classes2 = table.part(table.u16(10));
 		const count1 = table.u16(12);
 		const count2 = table.u16(14);
-		return (first, second) => {
+		const pair = (first, second) => {
 			if (coverageIndex(coverage, first) < 0) return void 0;
 			const class1 = classOf(classes1, first);
 			const class2 = classOf(classes2, second);
@@ -206,6 +252,30 @@ function pairSubtable(table, store) {
 			const at = 16 + (class1 * count2 + class2) * (size1 + size2);
 			return pairValue(xAdvance(table, at, format1, table, store), xAdvance(table, at + size1, format2, table, store), skipSecond);
 		};
+		const largest = (glyphs) => {
+			const firsts = /* @__PURE__ */ new Set();
+			const seconds = /* @__PURE__ */ new Set();
+			for (const glyph of glyphs) {
+				if (coverageIndex(coverage, glyph) >= 0) firsts.add(classOf(classes1, glyph));
+				seconds.add(classOf(classes2, glyph));
+			}
+			let first = 0;
+			let second = 0;
+			for (const class1 of firsts) for (const class2 of seconds) {
+				if (class1 >= count1 || class2 >= count2) continue;
+				const at = 16 + (class1 * count2 + class2) * (size1 + size2);
+				first = Math.max(first, xAdvance(table, at, format1, table, store).value);
+				second = Math.max(second, xAdvance(table, at + size1, format2, table, store).value);
+			}
+			return {
+				first,
+				second
+			};
+		};
+		return {
+			pair,
+			largest
+		};
 	}
 	throw new Error(`the PairPos format ${format} is unknown`);
 }
@@ -278,9 +348,16 @@ function readGposKerning(gpos, script, store, filter) {
 			...skip === void 0 ? {} : { skip },
 			pair(first, second) {
 				for (const subtable of subtables) {
-					const value = subtable(first, second);
+					const value = subtable.pair(first, second);
 					if (value !== void 0) return value;
 				}
+			},
+			largest(glyphs) {
+				const values = subtables.map((subtable) => subtable.largest(glyphs));
+				return {
+					first: Math.max(...values.map((value) => value.first)),
+					second: Math.max(...values.map((value) => value.second))
+				};
 			}
 		}];
 	});
@@ -313,6 +390,14 @@ function readKernTable(kern) {
 				second: 0,
 				skipSecond: false
 			};
+		},
+		largest(glyphs) {
+			let first = 0;
+			for (const [key, value] of pairs) if (glyphs.has(Math.floor(key / 65536)) && glyphs.has(key % 65536)) first = Math.max(first, value);
+			return {
+				first,
+				second: 0
+			};
 		}
 	}];
 }
@@ -540,6 +625,81 @@ function records(table, at, count) {
 		lookupIndex: table.u16(at + k * 4 + 2)
 	}));
 }
+/** This function gives each rule table of the rule sets at `at` of a context subtable of format 1 or 2. An offset 0 is an empty set. */
+function ruleTables(t, at) {
+	const tables = [];
+	for (let s = 0; s < t.u16(at); s++) {
+		const offset = t.u16(at + 2 + s * 2);
+		if (offset === 0) continue;
+		const set = t.part(offset);
+		for (let r = 0; r < set.u16(0); r++) tables.push(set.part(set.u16(2 + r * 2)));
+	}
+	return tables;
+}
+/** This function gives the records of each rule of a context subtable (lookup type 5). */
+function contextRecords(t) {
+	const format = t.u16(0);
+	if (format === 3) return records(t, 6 + t.u16(2) * 2, t.u16(4));
+	return ruleTables(t, format === 2 ? 6 : 4).flatMap((rule) => records(rule, 4 + (rule.u16(0) - 1) * 2, rule.u16(2)));
+}
+/** This function gives the records of each rule of a chained context subtable (lookup type 6). */
+function chainRecords(t) {
+	const format = t.u16(0);
+	if (format === 3) {
+		const inputAt = 4 + t.u16(2) * 2;
+		const aheadAt = inputAt + 2 + t.u16(inputAt) * 2;
+		const recordsAt = aheadAt + 2 + t.u16(aheadAt) * 2;
+		return records(t, recordsAt + 2, t.u16(recordsAt));
+	}
+	return ruleTables(t, format === 2 ? 10 : 4).flatMap((rule) => {
+		const inputAt = 2 + rule.u16(0) * 2;
+		const aheadAt = inputAt + 2 + Math.max(0, rule.u16(inputAt) - 1) * 2;
+		const recordsAt = aheadAt + 2 + rule.u16(aheadAt) * 2;
+		return records(rule, recordsAt + 2, rule.u16(recordsAt));
+	});
+}
+/** This function adds the rules of one subtable of a lookup type to `rules`, and each nested lookup to `nested`. */
+function readRules(type, t, rules, nested) {
+	if (type === 5 || type === 6) {
+		for (const record of type === 5 ? contextRecords(t) : chainRecords(t)) nested.push(record.lookupIndex);
+		return;
+	}
+	if (type < 1 || type > 8 || type === 7) return;
+	const format = t.u16(0);
+	for (const [from, index] of coverageGlyphs(t.part(t.u16(2)))) if (type === 1) rules.push({
+		from,
+		to: [format === 1 ? from + t.i16(4) & 65535 : t.u16(6 + index * 2)]
+	});
+	else if (type === 2) {
+		const sequence = t.part(t.u16(6 + index * 2));
+		rules.push({
+			from,
+			to: Array.from({ length: sequence.u16(0) }, (_, k) => sequence.u16(2 + k * 2))
+		});
+	} else if (type === 3) {
+		const set = t.part(t.u16(6 + index * 2));
+		for (let k = 0; k < set.u16(0); k++) rules.push({
+			from,
+			to: [set.u16(2 + k * 2)]
+		});
+	} else if (type === 4) {
+		const set = t.part(t.u16(6 + index * 2));
+		for (let l = 0; l < set.u16(0); l++) {
+			const ligature = set.part(set.u16(2 + l * 2));
+			rules.push({
+				from,
+				to: [ligature.u16(0)],
+				components: Array.from({ length: ligature.u16(2) - 1 }, (_, k) => ligature.u16(4 + k * 2))
+			});
+		}
+	} else {
+		const aheadAt = 6 + t.u16(4) * 2;
+		rules.push({
+			from,
+			to: [t.u16(aheadAt + 2 + t.u16(aheadAt) * 2 + 2 + index * 2)]
+		});
+	}
+}
 /** The lookups of one GSUB table. It reads each lookup at its first use. */
 var Gsub = class {
 	lookups;
@@ -800,6 +960,23 @@ var Gsub = class {
 			return false;
 		});
 	}
+	/** This function gives the rules of a lookup and of each lookup that it nests, as `rules` of `SubstitutionLookup` tells. */
+	rulesOf(index) {
+		const lists = [];
+		const seen = /* @__PURE__ */ new Set();
+		const visit = (at) => {
+			const lookup = this.lookup(at);
+			if (seen.has(at) || lookup === void 0) return;
+			seen.add(at);
+			const rules = [];
+			const nested = [];
+			for (const subtable of lookup.subtables) readRules(lookup.type, subtable, rules, nested);
+			lists.push(rules);
+			nested.forEach(visit);
+		};
+		visit(index);
+		return lists;
+	}
 	/** This function applies one subtable at `i`. It gives the next position, or -1 when the subtable does not match. */
 	subtable(lookup, t, glyphs, i, depth) {
 		const glyph = glyphs[i];
@@ -977,7 +1154,8 @@ function readSubstitutions(gsub, script, features, filter) {
 			features: tags,
 			apply: (glyphs, masks, mask) => table.applyAll(index, glyphs, masks, mask),
 			applyInfos: (glyphs, infos, mask, perSyllable) => table.applyRun(index, glyphs, infos, mask, perSyllable),
-			wouldApply: (glyphs) => table.wouldApply(index, glyphs)
+			wouldApply: (glyphs) => table.wouldApply(index, glyphs),
+			rules: () => table.rulesOf(index)
 		});
 	}
 	return result;
@@ -1717,17 +1895,7 @@ function vowelConstraints(codePoints) {
 */
 function normalize(codePoints, hasGlyph) {
 	const allSimple = !codePoints.some((codePoint, i) => i > 0 && isMark(codePoint));
-	const decomposed = [];
-	for (const codePoint of codePoints) {
-		const parts = codePoint === 2353 ? [codePoint] : [...String.fromCodePoint(codePoint).normalize("NFD")].map((part) => part.codePointAt(0));
-		if (parts.length > 1 || parts[0] !== codePoint) {
-			if (parts.every(hasGlyph)) {
-				decomposed.push(...parts);
-				continue;
-			}
-		}
-		decomposed.push(codePoint);
-	}
+	const decomposed = codePoints.flatMap((codePoint) => decomposition(codePoint, hasGlyph));
 	if (allSimple) return decomposed;
 	for (let i = 1; i < decomposed.length; i++) for (let j = i; j > 0; j--) {
 		const before = combiningClass(decomposed[j - 1]);
@@ -1751,6 +1919,38 @@ function normalize(codePoints, hasGlyph) {
 	}
 	return out;
 }
+/** This function gives the code points of a character after the decomposition of `normalize`. */
+function decomposition(codePoint, hasGlyph) {
+	const parts = codePoint === 2353 ? [codePoint] : [...String.fromCodePoint(codePoint).normalize("NFD")].map((part) => part.codePointAt(0));
+	return (parts.length > 1 || parts[0] !== codePoint) && parts.every(hasGlyph) ? parts : [codePoint];
+}
+/**
+* This function gives the code points that the normalization can give for the characters `characters`. A composite is
+* not always in the set: a nukta that follows U+0928 gives U+0929. The function repeats until no new composite appears.
+*/
+function indicForms(characters, hasGlyph) {
+	const parts = new Map([...characters].map((codePoint) => [codePoint, decomposition(codePoint, hasGlyph)]));
+	const codePoints = new Set([...parts.values()].flat());
+	for (const codePoint of characters) codePoints.add(codePoint);
+	codePoints.add(9676);
+	const composites = /* @__PURE__ */ new Map();
+	for (let size = 0; size !== codePoints.size;) {
+		size = codePoints.size;
+		const marks = [...codePoints].filter(isMark);
+		for (const starter of codePoints) for (const mark of marks) {
+			const composed = compose(starter, mark);
+			if (composed === void 0 || !hasGlyph(composed)) continue;
+			const known = composites.get(starter) ?? [];
+			if (!known.includes(composed)) composites.set(starter, [...known, composed]);
+			codePoints.add(composed);
+		}
+	}
+	return {
+		parts,
+		composites,
+		codePoints
+	};
+}
 /** This function gives the canonical composite of two code points, or `undefined`. A mark does not compose with a mark. */
 function compose(first, second) {
 	if (isMark(first)) return void 0;
@@ -1869,6 +2069,24 @@ const finalFeatures = [
 	"psts",
 	"haln"
 ];
+/** This function gives the features of the page that the last stage applies. */
+function pageFeatures(features) {
+	return features.filter((tag) => ![
+		"ccmp",
+		"locl",
+		"liga"
+	].includes(tag) && !finalFeatures.includes(tag));
+}
+/** This function gives all the features that `indicShaper` applies for the features `features` of the page. */
+function indicFeatures(features) {
+	return [
+		"locl",
+		"ccmp",
+		...basicFeatures.map(([tag]) => tag),
+		...finalFeatures,
+		...pageFeatures(features)
+	];
+}
 /** The mask bit of the global features. Each glyph has it. */
 const GLOBAL = 1;
 /** The mask bits of the features that apply only to some glyphs of a syllable. */
@@ -1940,12 +2158,7 @@ function indicShaper(font, script, features) {
 		lookups: lookupsOf([tag]),
 		mask: global ? GLOBAL : featureBits.get(tag)
 	}));
-	const extra = features.filter((tag) => ![
-		"ccmp",
-		"locl",
-		"liga"
-	].includes(tag) && !finalFeatures.includes(tag));
-	const last = lookupsOf([...finalFeatures, ...extra]).map((lookup) => ({
+	const last = lookupsOf([...finalFeatures, ...pageFeatures(features)]).map((lookup) => ({
 		lookup,
 		mask: lookup.features.reduce((mask, tag) => mask | (tag === "init" ? initMask : GLOBAL), 0),
 		perSyllable: lookup.features.some((tag) => finalFeatures.includes(tag))
@@ -3401,16 +3614,32 @@ function shapingWords(text) {
 	if (word !== "") words.push(word);
 	return words;
 }
-/** The GSUB pass of one set of options: a function that gives the glyphs of one word, and the kerning lookups. */
-function shaperOf(font, options) {
+/** This function gives the choices of a set of options: the script, the features, the shaper and the kerning lookups. */
+function shapingOf(font, options) {
 	const script = options.script ?? "DFLT";
 	const features = options.features ?? defaultFeatures;
 	const kerning = options.kerning === false ? [] : font.kerning(script);
 	if (options.indic !== false && indicScripts.includes(script)) return {
+		script,
+		features,
+		shaper: "indic",
+		kerning
+	};
+	return {
+		script,
+		features,
+		shaper: options.joining !== false && joiningScripts.includes(script) ? "joining" : "plain",
+		kerning
+	};
+}
+/** The GSUB pass of one set of options: a function that gives the glyphs of one word, and the kerning lookups. */
+function shaperOf(font, options) {
+	const { script, features, shaper, kerning } = shapingOf(font, options);
+	if (shaper === "indic") return {
 		substitute: indicShaper(font, script, features),
 		kerning
 	};
-	const joins = options.joining !== false && joiningScripts.includes(script);
+	const joins = shaper === "joining";
 	const lookups = joins ? [] : font.substitutions(script, features);
 	const stages = joins ? joiningStages(features, features.includes("rclt") && font.substitutions(script, ["rclt"]).length > 0).map((stage) => ({
 		stage,
@@ -3545,6 +3774,6 @@ function measureWidth(font, text, size, options = {}) {
 	for (const advance of advances) units += advance;
 	return units * size / font.unitsPerEm;
 }
-export { canvasWords as a, shapingWords as i, measureWidth as n, defaultFeatures as o, readFont as r, readTables as s, glyphAdvances as t };
+export { shapingWords as a, indicFeatures as c, readTables as d, shapingOf as i, indicForms as l, measureWidth as n, canvasWords as o, readFont as r, joiningStages as s, glyphAdvances as t, defaultFeatures as u };
 
 //# sourceMappingURL=font.js.map