@mark1russell7/typeset 0.1.2 → 0.1.3

package/build/chunks/fonts.d.ts

@@ -1,8 +1,31 @@
 import { a as measureWidth, c as Axis, l as Instance, n as MeasureOptions, o as readFont, r as ReadOptions, t as Font } from "./font.js";
 import { i as isEngineName, n as EngineRules, r as engines, t as EngineName } from "./engines.js";
 import { t as Decompress } from "./sfnt.js";
+/** The limit of `widthBound` for the width of a text over a declared set of characters. It needs no measurement. */
+interface WidthBound {
+  /** The largest total advance of one character with all its expansions, in font units. */
+  readonly advance: number;
+  /** The largest positive kerning of one glyph, in font units. */
+  readonly kerning: number;
+  /** The largest count of glyphs of one character. */
+  readonly glyphs: number;
+  /**
+   * This function gives the limit in px for a text of `length` UTF-16 units at the size `size`. It takes the length of a
+   * string, so it does not read the text. The limit is for a text with only the characters of the set.
+   */
+  width(length: number, size: number): number;
+}
+/**
+ * This function gives a limit for the width of each text over the characters `characters`, with no measurement. For each such
+ * text, `measureWidth(font, text, size, options)` is at most `width(text.length, size)` of the result. Give the same `options`.
+ * A text with another character has no limit from this function.
+ *
+ * The limit is sound, not tight. It follows the widest character of the set. It includes each glyph of the GSUB closure, each
+ * dotted circle, each part or composite of the Indic normalization, and the largest positive kerning.
+ */
+declare function widthBound(font: Font, characters: string, options?: MeasureOptions): WidthBound;
 declare namespace fonts_d_exports {
-  export { Axis, Decompress, EngineName, EngineRules, Font, Instance, MeasureOptions, ReadOptions, engines, isEngineName, measureWidth, readFont };
+  export { Axis, Decompress, EngineName, EngineRules, Font, Instance, MeasureOptions, ReadOptions, WidthBound, engines, isEngineName, measureWidth, readFont, widthBound };
 }
-export { fonts_d_exports as t };
+export { WidthBound as n, widthBound as r, fonts_d_exports as t };
 //# sourceMappingURL=fonts.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"fonts.d.ts","names":[],"sources":["../../src/fonts.ts"],"mappings":""}
+{"version":3,"file":"fonts.d.ts","names":[],"sources":["../../src/fonts/bound.ts","../../src/fonts.ts"],"mappings":";;;;UAMiB;;WAEN;;WAEA;;WAEA;;;;;EAKT,MAAM,gBAAgB;;;;;;;;;;iBA6FR,WAAW,MAAM,MAAM,oBAAoB,UAAS,iBAAsB"}

package/build/chunks/fonts.js

@@ -1,13 +1,150 @@
 import { t as __exportAll } from "./rolldown-runtime.js";
-import { n as measureWidth, r as readFont } from "./font.js";
+import { c as indicFeatures, i as shapingOf, l as indicForms, n as measureWidth, r as readFont, s as joiningStages } from "./font.js";
 import { n as isEngineName, t as engines } from "./engines.js";
+// src/fonts/bound.ts
+/**
+* The largest count of passes over the lookups of a shaper with stages. A pass covers one stage, and no shaper has more stages:
+* the Indic shaper has 13 and the joining has 11. A rule that expands its own glyph has no fixed point, so it stops at this count.
+*/
+const ROUNDS = 16;
+/** The relative error of one rounding to single precision. */
+const FLOAT32 = 2 ** -24;
+/** The relative error of one rounding to double precision. */
+const FLOAT64 = 2 ** -53;
+/** The largest size of a kerning value of a `ValueRecord`, and of its variation delta, in font units: the range of `int16`. */
+const KERNING_RANGE = 2 ** 15;
+function larger(a, b) {
+	return {
+		advance: Math.max(a.advance, b.advance),
+		glyphs: Math.max(a.glyphs, b.glyphs)
+	};
+}
+function sum(a, b) {
+	return {
+		advance: a.advance + b.advance,
+		glyphs: a.glyphs + b.glyphs
+	};
+}
+/** This function tells if a rule can apply to the glyphs `reached`. A ligature needs its first glyph and all its components. */
+function applies(rule, reached) {
+	return reached.has(rule.from) && (rule.components ?? []).every((glyph) => reached.has(glyph));
+}
+/** This function adds the glyphs that the rules can give to `reached`. */
+function reach(reached, rules) {
+	for (let size = -1; size !== reached.size;) {
+		size = reached.size;
+		for (const rule of rules) if (applies(rule, reached)) for (const glyph of rule.to) reached.add(glyph);
+	}
+}
+/**
+* This function applies one list of rules to the expansions. Each rule uses the values from before the list. A lookup applies
+* once at a position, so its output does not go back into it. The function tells if a value changed.
+*/
+function relax(rules, expansions) {
+	const changes = [];
+	for (const { from, to } of rules) {
+		const before = expansions.get(from);
+		const after = to.reduce((total, glyph) => sum(total, expansions.get(glyph)), {
+			advance: 0,
+			glyphs: 0
+		});
+		if (after.advance > before.advance || after.glyphs > before.glyphs) changes.push([from, after]);
+	}
+	for (const [from, after] of changes) expansions.set(from, larger(expansions.get(from), after));
+	return changes.length > 0;
+}
+/**
+* This function gives the largest expansion of each glyph of `reached`. Each ligature charges its first glyph, so each output
+* glyph comes from one input glyph. Each pass goes backward over the lookups: a glyph then gets the expansions of the lookups
+* after the lookup that makes it. A shaper with stages goes over the list again for each stage, so the passes repeat.
+*
+* One context rule can apply its nested lookups in any order. So the lists of a lookup with nested lookups repeat until no
+* value changes, with the same limit. A value that stops changing holds for each order.
+*/
+function expansionsOf(font, reached, lookups, rounds) {
+	const expansions = /* @__PURE__ */ new Map();
+	for (const glyph of reached) expansions.set(glyph, {
+		advance: Math.max(0, font.advance(glyph)),
+		glyphs: 1
+	});
+	const active = lookups.map((lists) => lists.map((rules) => rules.filter((rule) => applies(rule, reached))));
+	for (let round = 0; round < rounds; round++) {
+		let changed = false;
+		for (let i = active.length - 1; i >= 0; i--) {
+			const lists = active[i];
+			for (let step = 0; step < (lists.length > 1 ? ROUNDS : 1); step++) {
+				let moved = false;
+				for (const rules of lists) moved = relax(rules, expansions) || moved;
+				if (!moved) break;
+				changed = true;
+			}
+		}
+		if (!changed) break;
+	}
+	return expansions;
+}
+/**
+* This function gives a limit for the width of each text over the characters `characters`, with no measurement. For each such
+* text, `measureWidth(font, text, size, options)` is at most `width(text.length, size)` of the result. Give the same `options`.
+* A text with another character has no limit from this function.
+*
+* The limit is sound, not tight. It follows the widest character of the set. It includes each glyph of the GSUB closure, each
+* dotted circle, each part or composite of the Indic normalization, and the largest positive kerning.
+*/
+function widthBound(font, characters, options = {}) {
+	const { script, features, shaper, kerning: pairLookups } = shapingOf(font, options);
+	const set = new Set(Array.from(characters, (character) => character.codePointAt(0)));
+	const indic = shaper === "indic" ? indicForms(set, (codePoint) => font.glyph(codePoint) !== 0) : void 0;
+	const reached = new Set([...indic?.codePoints ?? set].map((codePoint) => font.glyph(codePoint)));
+	const tags = shaper === "indic" ? indicFeatures(features) : shaper === "joining" ? joiningStages(features, true).flatMap((stage) => stage.features) : features;
+	const lookups = font.substitutions(script, tags).map((lookup) => lookup.rules());
+	reach(reached, lookups.flat(2));
+	const expansions = expansionsOf(font, reached, lookups, shaper === "plain" ? 1 : ROUNDS);
+	const form = (codePoint) => (indic?.composites.get(codePoint) ?? []).reduce((best, composite) => larger(best, form(composite)), expansions.get(font.glyph(codePoint)));
+	const inserted = indic === void 0 ? {
+		advance: 0,
+		glyphs: 0
+	} : expansions.get(font.glyph(9676));
+	let largest = {
+		advance: 0,
+		glyphs: 0
+	};
+	for (const codePoint of set) {
+		const parts = indic?.parts.get(codePoint) ?? [codePoint];
+		largest = larger(largest, parts.reduce((total, part) => sum(total, sum(form(part), inserted)), {
+			advance: 0,
+			glyphs: 0
+		}));
+	}
+	let kerning = 0;
+	for (const lookup of pairLookups) {
+		const { first, second } = lookup.largest(reached);
+		kerning += first + second;
+	}
+	const { advance, glyphs } = largest;
+	const pixel = options.rounding === "pixel";
+	const float32 = options.sum === "float32" && !pixel;
+	const pixelMargin = pixel ? .5078125 + (kerning > 0 ? .5 : 0) : 0;
+	const positions = pairLookups.length * 2;
+	const positionMargin = float32 ? positions * (1.5 + 2 * KERNING_RANGE / font.unitsPerEm) / 65536 : 0;
+	const kerningMargin = float32 ? positions * 5 * FLOAT32 * KERNING_RANGE : 0;
+	return {
+		advance,
+		kerning,
+		glyphs,
+		width(length, size) {
+			return length * ((advance + glyphs * (kerning + kerningMargin)) * (size / font.unitsPerEm) + glyphs * (pixelMargin + positionMargin)) * (float32 ? (1 + FLOAT32) ** (length + 6) : 1) * (1 + (8192 + length) * FLOAT64);
+		}
+	};
+}
 // src/fonts.ts
 var fonts_exports = /* @__PURE__ */ __exportAll({
 	engines: () => engines,
 	isEngineName: () => isEngineName,
 	measureWidth: () => measureWidth,
-	readFont: () => readFont
+	readFont: () => readFont,
+	widthBound: () => widthBound
 });
-export { fonts_exports as t };
+export { widthBound as n, fonts_exports as t };
 
 //# sourceMappingURL=fonts.js.map

package/build/chunks/fonts.js.map

@@ -1 +1 @@
-{"version":3,"file":"fonts.js","names":[],"sources":["../../src/fonts.ts"],"sourcesContent":["/**\n * The subpath `./fonts`: the font model of typeset. It reads the tables of a TrueType, OpenType or WOFF2 file. It gives\n * the width of a text as the text engine of a browser gives it. The host gives the bytes of the font files.\n */\nexport { measureWidth, readFont, type Font, type MeasureOptions, type ReadOptions } from \"./fonts/font.ts\";\nexport { engines, isEngineName, type EngineName, type EngineRules } from \"./fonts/engines.ts\";\nexport type { Decompress } from \"./fonts/sfnt.ts\";\nexport type { Axis, Instance } from \"./fonts/variations.ts\";\n"],"mappings":""}
+{"version":3,"file":"fonts.js","names":[],"sources":["../../src/fonts/bound.ts","../../src/fonts.ts"],"sourcesContent":["import { shapingOf, type Font, type MeasureOptions } from \"./font.ts\";\nimport { indicFeatures, indicForms } from \"./indic.ts\";\nimport { joiningStages } from \"./joining.ts\";\nimport type { SubstitutionRule } from \"./substitution.ts\";\n\n/** The limit of `widthBound` for the width of a text over a declared set of characters. It needs no measurement. */\nexport interface WidthBound {\n  /** The largest total advance of one character with all its expansions, in font units. */\n  readonly advance: number;\n  /** The largest positive kerning of one glyph, in font units. */\n  readonly kerning: number;\n  /** The largest count of glyphs of one character. */\n  readonly glyphs: number;\n  /**\n   * This function gives the limit in px for a text of `length` UTF-16 units at the size `size`. It takes the length of a\n   * string, so it does not read the text. The limit is for a text with only the characters of the set.\n   */\n  width(length: number, size: number): number;\n}\n\n/**\n * The largest count of passes over the lookups of a shaper with stages. A pass covers one stage, and no shaper has more stages:\n * the Indic shaper has 13 and the joining has 11. A rule that expands its own glyph has no fixed point, so it stops at this count.\n */\nconst ROUNDS = 16;\n/** The relative error of one rounding to single precision. */\nconst FLOAT32 = 2 ** -24;\n/** The relative error of one rounding to double precision. */\nconst FLOAT64 = 2 ** -53;\n/** The largest size of a kerning value of a `ValueRecord`, and of its variation delta, in font units: the range of `int16`. */\nconst KERNING_RANGE = 2 ** 15;\n\n/** The largest expansion of a glyph: the sum of its advances, and the count of its glyphs. */\ninterface Expansion {\n  readonly advance: number;\n  readonly glyphs: number;\n}\n\nfunction larger(a: Expansion, b: Expansion): Expansion {\n  return { advance: Math.max(a.advance, b.advance), glyphs: Math.max(a.glyphs, b.glyphs) };\n}\n\nfunction sum(a: Expansion, b: Expansion): Expansion {\n  return { advance: a.advance + b.advance, glyphs: a.glyphs + b.glyphs };\n}\n\n/** This function tells if a rule can apply to the glyphs `reached`. A ligature needs its first glyph and all its components. */\nfunction applies(rule: SubstitutionRule, reached: ReadonlySet<number>): boolean {\n  return reached.has(rule.from) && (rule.components ?? []).every((glyph) => reached.has(glyph));\n}\n\n/** This function adds the glyphs that the rules can give to `reached`. */\nfunction reach(reached: Set<number>, rules: readonly SubstitutionRule[]): void {\n  for (let size = -1; size !== reached.size; ) {\n    size = reached.size;\n    for (const rule of rules) if (applies(rule, reached)) for (const glyph of rule.to) reached.add(glyph);\n  }\n}\n\n/**\n * This function applies one list of rules to the expansions. Each rule uses the values from before the list. A lookup applies\n * once at a position, so its output does not go back into it. The function tells if a value changed.\n */\nfunction relax(rules: readonly SubstitutionRule[], expansions: Map<number, Expansion>): boolean {\n  const changes: (readonly [number, Expansion])[] = [];\n  for (const { from, to } of rules) {\n    const before = expansions.get(from)!;\n    const after = to.reduce((total, glyph) => sum(total, expansions.get(glyph)!), { advance: 0, glyphs: 0 });\n    if (after.advance > before.advance || after.glyphs > before.glyphs) changes.push([from, after]);\n  }\n  for (const [from, after] of changes) expansions.set(from, larger(expansions.get(from)!, after));\n  return changes.length > 0;\n}\n\n/**\n * This function gives the largest expansion of each glyph of `reached`. Each ligature charges its first glyph, so each output\n * glyph comes from one input glyph. Each pass goes backward over the lookups: a glyph then gets the expansions of the lookups\n * after the lookup that makes it. A shaper with stages goes over the list again for each stage, so the passes repeat.\n *\n * One context rule can apply its nested lookups in any order. So the lists of a lookup with nested lookups repeat until no\n * value changes, with the same limit. A value that stops changing holds for each order.\n */\nfunction expansionsOf(font: Font, reached: ReadonlySet<number>, lookups: readonly (readonly (readonly SubstitutionRule[])[])[], rounds: number): Map<number, Expansion> {\n  const expansions = new Map<number, Expansion>();\n  for (const glyph of reached) expansions.set(glyph, { advance: Math.max(0, font.advance(glyph)), glyphs: 1 });\n  const active = lookups.map((lists) => lists.map((rules) => rules.filter((rule) => applies(rule, reached))));\n  for (let round = 0; round < rounds; round++) {\n    let changed = false;\n    for (let i = active.length - 1; i >= 0; i--) {\n      const lists = active[i]!;\n      for (let step = 0; step < (lists.length > 1 ? ROUNDS : 1); step++) {\n        let moved = false;\n        for (const rules of lists) moved = relax(rules, expansions) || moved;\n        if (!moved) break;\n        changed = true;\n      }\n    }\n    if (!changed) break;\n  }\n  return expansions;\n}\n\n/**\n * This function gives a limit for the width of each text over the characters `characters`, with no measurement. For each such\n * text, `measureWidth(font, text, size, options)` is at most `width(text.length, size)` of the result. Give the same `options`.\n * A text with another character has no limit from this function.\n *\n * The limit is sound, not tight. It follows the widest character of the set. It includes each glyph of the GSUB closure, each\n * dotted circle, each part or composite of the Indic normalization, and the largest positive kerning.\n */\nexport function widthBound(font: Font, characters: string, options: MeasureOptions = {}): WidthBound {\n  const { script, features, shaper, kerning: pairLookups } = shapingOf(font, options);\n  const set = new Set(Array.from(characters, (character) => character.codePointAt(0)!));\n  const indic = shaper === \"indic\" ? indicForms(set, (codePoint) => font.glyph(codePoint) !== 0) : undefined;\n\n  // The roots: the glyph of each code point that the shaper can see. A character with no glyph gives the glyph 0\n  const reached = new Set([...(indic?.codePoints ?? set)].map((codePoint) => font.glyph(codePoint)));\n  // A union of the features gives the same lookups as the union of the stages. Each stage then counts, in the rounds\n  const tags = shaper === \"indic\" ? indicFeatures(features) : shaper === \"joining\" ? joiningStages(features, true).flatMap((stage) => stage.features) : features;\n  const lookups = font.substitutions(script, tags).map((lookup) => lookup.rules());\n  reach(reached, lookups.flat(2));\n  // The plain shaper is one stage: it applies each lookup once, in the order of the list\n  const expansions = expansionsOf(font, reached, lookups, shaper === \"plain\" ? 1 : ROUNDS);\n\n  const form = (codePoint: number): Expansion => (indic?.composites.get(codePoint) ?? []).reduce((best, composite) => larger(best, form(composite)), expansions.get(font.glyph(codePoint))!);\n  // The Indic shaper can insert a dotted circle before each code point. Without a glyph, the code point U+25CC gives the glyph 0.\n  // One code point gets at most one: a circle of the vowel constraints takes the next matra, so that syllable is not broken\n  const inserted = indic === undefined ? { advance: 0, glyphs: 0 } : expansions.get(font.glyph(0x25cc))!;\n  let largest: Expansion = { advance: 0, glyphs: 0 };\n  for (const codePoint of set) {\n    const parts = indic?.parts.get(codePoint) ?? [codePoint];\n    largest = larger(largest, parts.reduce((total, part) => sum(total, sum(form(part), inserted)), { advance: 0, glyphs: 0 }));\n  }\n\n  // One glyph gets at most one first value and one second value from each lookup, and each subtable of a lookup is an alternative\n  let kerning = 0;\n  for (const lookup of pairLookups) {\n    const { first, second } = lookup.largest(reached);\n    kerning += first + second;\n  }\n\n  const { advance, glyphs } = largest;\n  const pixel = options.rounding === \"pixel\";\n  const float32 = options.sum === \"float32\" && !pixel;\n  // Pixel: an advance gets at most 1/128 px from the grid of 26.6, and then 0.5 px. A kerning sum gets at most 0.5 px\n  const pixelMargin = pixel ? 0.5 + 1 / 128 + (kerning > 0 ? 0.5 : 0) : 0;\n  // Float32: each lookup gives a glyph two positions, in units of 1/65536 px. A negative value gets no help from the relative\n  // factor below, so it has its own margin. The floor of a value and the round of a delta give 1 unit, the floor of the\n  // multiplier gives 0.5 units, and the cut of the scale gives KERNING_RANGE / unitsPerEm units to each of the two parts.\n  // The single precision gives FLOAT32 to the value and 4 FLOAT32 to the delta\n  const positions = pairLookups.length * 2;\n  const positionMargin = float32 ? (positions * (1.5 + (2 * KERNING_RANGE) / font.unitsPerEm)) / 65536 : 0;\n  const kerningMargin = float32 ? positions * 5 * FLOAT32 * KERNING_RANGE : 0;\n  return {\n    advance,\n    kerning,\n    glyphs,\n    width(length: number, size: number): number {\n      const total = length * ((advance + glyphs * (kerning + kerningMargin)) * (size / font.unitsPerEm) + glyphs * (pixelMargin + positionMargin));\n      // Float32: the fround of a glyph or 4 steps of a positive delta, the fround of a segment, and one step of the sum for\n      // each segment. A text has at most one segment for each UTF-16 unit\n      const single = float32 ? (1 + FLOAT32) ** (length + 6) : 1;\n      // The double precision: the scale and a few products, and one rounding for each step of a sum of fractions\n      return total * single * (1 + (2 ** 13 + length) * FLOAT64);\n    },\n  };\n}\n","/**\n * The subpath `./fonts`: the font model of typeset. It reads the tables of a TrueType, OpenType or WOFF2 file. It gives\n * the width of a text as the text engine of a browser gives it. The host gives the bytes of the font files.\n */\nexport { measureWidth, readFont, type Font, type MeasureOptions, type ReadOptions } from \"./fonts/font.ts\";\nexport { widthBound, type WidthBound } from \"./fonts/bound.ts\";\nexport { engines, isEngineName, type EngineName, type EngineRules } from \"./fonts/engines.ts\";\nexport type { Decompress } from \"./fonts/sfnt.ts\";\nexport type { Axis, Instance } from \"./fonts/variations.ts\";\n"],"mappings":"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"}

package/build/fonts-inspect.js

@@ -1 +1 @@
-export { a as canvasWords, o as defaultFeatures, t as glyphAdvances, s as readTables, i as shapingWords } from "./chunks/font.js";
+export { o as canvasWords, u as defaultFeatures, t as glyphAdvances, d as readTables, a as shapingWords } from "./chunks/font.js";

package/build/fonts.d.ts

@@ -1,5 +1,5 @@
 import { t as Decompress } from "./chunks/sfnt.js";
 import { a as measureWidth, c as Axis, l as Instance, n as MeasureOptions, o as readFont, r as ReadOptions, t as Font } from "./chunks/font.js";
+import { n as WidthBound, r as widthBound } from "./chunks/fonts.js";
 import { i as isEngineName, n as EngineRules, r as engines, t as EngineName } from "./chunks/engines.js";
-import "./chunks/fonts.js";
-export { type Axis, type Decompress, type EngineName, type EngineRules, type Font, type Instance, type MeasureOptions, type ReadOptions, engines, isEngineName, measureWidth, readFont };
+export { type Axis, type Decompress, type EngineName, type EngineRules, type Font, type Instance, type MeasureOptions, type ReadOptions, type WidthBound, engines, isEngineName, measureWidth, readFont, widthBound };

package/build/fonts.js

@@ -1,4 +1,4 @@
 import { n as measureWidth, r as readFont } from "./chunks/font.js";
+import { n as widthBound } from "./chunks/fonts.js";
 import { n as isEngineName, t as engines } from "./chunks/engines.js";
-import "./chunks/fonts.js";
-export { engines, isEngineName, measureWidth, readFont };
+export { engines, isEngineName, measureWidth, readFont, widthBound };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/typeset",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Text measurement and line breaking. The subpath ./fonts reads font tables and gives widths, ./measurer gives the advance function of a layout, ./breaking has the line breakers, and ./text has a rope.",
   "keywords": [
     "typeset",
@@ -68,7 +68,7 @@
     "@mark1russell7/rigor-generators": "^0.1.0"
   },
   "devDependencies": {
-    "@mark1russell7/cue": "^1.0.2",
+    "@mark1russell7/cue": "^2.0.0",
     "@mark1russell7/layout-contract": "^0.3.2",
     "@types/node": "^26.6.5",
     "@typeset/corpus": "0.1.0",

package/src/fonts/bound.ts

@@ -0,0 +1,167 @@
+import { shapingOf, type Font, type MeasureOptions } from "./font.ts";
+import { indicFeatures, indicForms } from "./indic.ts";
+import { joiningStages } from "./joining.ts";
+import type { SubstitutionRule } from "./substitution.ts";
+
+/** The limit of `widthBound` for the width of a text over a declared set of characters. It needs no measurement. */
+export interface WidthBound {
+  /** The largest total advance of one character with all its expansions, in font units. */
+  readonly advance: number;
+  /** The largest positive kerning of one glyph, in font units. */
+  readonly kerning: number;
+  /** The largest count of glyphs of one character. */
+  readonly glyphs: number;
+  /**
+   * This function gives the limit in px for a text of `length` UTF-16 units at the size `size`. It takes the length of a
+   * string, so it does not read the text. The limit is for a text with only the characters of the set.
+   */
+  width(length: number, size: number): number;
+}
+
+/**
+ * The largest count of passes over the lookups of a shaper with stages. A pass covers one stage, and no shaper has more stages:
+ * the Indic shaper has 13 and the joining has 11. A rule that expands its own glyph has no fixed point, so it stops at this count.
+ */
+const ROUNDS = 16;
+/** The relative error of one rounding to single precision. */
+const FLOAT32 = 2 ** -24;
+/** The relative error of one rounding to double precision. */
+const FLOAT64 = 2 ** -53;
+/** The largest size of a kerning value of a `ValueRecord`, and of its variation delta, in font units: the range of `int16`. */
+const KERNING_RANGE = 2 ** 15;
+
+/** The largest expansion of a glyph: the sum of its advances, and the count of its glyphs. */
+interface Expansion {
+  readonly advance: number;
+  readonly glyphs: number;
+}
+
+function larger(a: Expansion, b: Expansion): Expansion {
+  return { advance: Math.max(a.advance, b.advance), glyphs: Math.max(a.glyphs, b.glyphs) };
+}
+
+function sum(a: Expansion, b: Expansion): Expansion {
+  return { advance: a.advance + b.advance, glyphs: a.glyphs + b.glyphs };
+}
+
+/** This function tells if a rule can apply to the glyphs `reached`. A ligature needs its first glyph and all its components. */
+function applies(rule: SubstitutionRule, reached: ReadonlySet<number>): boolean {
+  return reached.has(rule.from) && (rule.components ?? []).every((glyph) => reached.has(glyph));
+}
+
+/** This function adds the glyphs that the rules can give to `reached`. */
+function reach(reached: Set<number>, rules: readonly SubstitutionRule[]): void {
+  for (let size = -1; size !== reached.size; ) {
+    size = reached.size;
+    for (const rule of rules) if (applies(rule, reached)) for (const glyph of rule.to) reached.add(glyph);
+  }
+}
+
+/**
+ * This function applies one list of rules to the expansions. Each rule uses the values from before the list. A lookup applies
+ * once at a position, so its output does not go back into it. The function tells if a value changed.
+ */
+function relax(rules: readonly SubstitutionRule[], expansions: Map<number, Expansion>): boolean {
+  const changes: (readonly [number, Expansion])[] = [];
+  for (const { from, to } of rules) {
+    const before = expansions.get(from)!;
+    const after = to.reduce((total, glyph) => sum(total, expansions.get(glyph)!), { advance: 0, glyphs: 0 });
+    if (after.advance > before.advance || after.glyphs > before.glyphs) changes.push([from, after]);
+  }
+  for (const [from, after] of changes) expansions.set(from, larger(expansions.get(from)!, after));
+  return changes.length > 0;
+}
+
+/**
+ * This function gives the largest expansion of each glyph of `reached`. Each ligature charges its first glyph, so each output
+ * glyph comes from one input glyph. Each pass goes backward over the lookups: a glyph then gets the expansions of the lookups
+ * after the lookup that makes it. A shaper with stages goes over the list again for each stage, so the passes repeat.
+ *
+ * One context rule can apply its nested lookups in any order. So the lists of a lookup with nested lookups repeat until no
+ * value changes, with the same limit. A value that stops changing holds for each order.
+ */
+function expansionsOf(font: Font, reached: ReadonlySet<number>, lookups: readonly (readonly (readonly SubstitutionRule[])[])[], rounds: number): Map<number, Expansion> {
+  const expansions = new Map<number, Expansion>();
+  for (const glyph of reached) expansions.set(glyph, { advance: Math.max(0, font.advance(glyph)), glyphs: 1 });
+  const active = lookups.map((lists) => lists.map((rules) => rules.filter((rule) => applies(rule, reached))));
+  for (let round = 0; round < rounds; round++) {
+    let changed = false;
+    for (let i = active.length - 1; i >= 0; i--) {
+      const lists = active[i]!;
+      for (let step = 0; step < (lists.length > 1 ? ROUNDS : 1); step++) {
+        let moved = false;
+        for (const rules of lists) moved = relax(rules, expansions) || moved;
+        if (!moved) break;
+        changed = true;
+      }
+    }
+    if (!changed) break;
+  }
+  return expansions;
+}
+
+/**
+ * This function gives a limit for the width of each text over the characters `characters`, with no measurement. For each such
+ * text, `measureWidth(font, text, size, options)` is at most `width(text.length, size)` of the result. Give the same `options`.
+ * A text with another character has no limit from this function.
+ *
+ * The limit is sound, not tight. It follows the widest character of the set. It includes each glyph of the GSUB closure, each
+ * dotted circle, each part or composite of the Indic normalization, and the largest positive kerning.
+ */
+export function widthBound(font: Font, characters: string, options: MeasureOptions = {}): WidthBound {
+  const { script, features, shaper, kerning: pairLookups } = shapingOf(font, options);
+  const set = new Set(Array.from(characters, (character) => character.codePointAt(0)!));
+  const indic = shaper === "indic" ? indicForms(set, (codePoint) => font.glyph(codePoint) !== 0) : undefined;
+
+  // The roots: the glyph of each code point that the shaper can see. A character with no glyph gives the glyph 0
+  const reached = new Set([...(indic?.codePoints ?? set)].map((codePoint) => font.glyph(codePoint)));
+  // A union of the features gives the same lookups as the union of the stages. Each stage then counts, in the rounds
+  const tags = shaper === "indic" ? indicFeatures(features) : shaper === "joining" ? joiningStages(features, true).flatMap((stage) => stage.features) : features;
+  const lookups = font.substitutions(script, tags).map((lookup) => lookup.rules());
+  reach(reached, lookups.flat(2));
+  // The plain shaper is one stage: it applies each lookup once, in the order of the list
+  const expansions = expansionsOf(font, reached, lookups, shaper === "plain" ? 1 : ROUNDS);
+
+  const form = (codePoint: number): Expansion => (indic?.composites.get(codePoint) ?? []).reduce((best, composite) => larger(best, form(composite)), expansions.get(font.glyph(codePoint))!);
+  // The Indic shaper can insert a dotted circle before each code point. Without a glyph, the code point U+25CC gives the glyph 0.
+  // One code point gets at most one: a circle of the vowel constraints takes the next matra, so that syllable is not broken
+  const inserted = indic === undefined ? { advance: 0, glyphs: 0 } : expansions.get(font.glyph(0x25cc))!;
+  let largest: Expansion = { advance: 0, glyphs: 0 };
+  for (const codePoint of set) {
+    const parts = indic?.parts.get(codePoint) ?? [codePoint];
+    largest = larger(largest, parts.reduce((total, part) => sum(total, sum(form(part), inserted)), { advance: 0, glyphs: 0 }));
+  }
+
+  // One glyph gets at most one first value and one second value from each lookup, and each subtable of a lookup is an alternative
+  let kerning = 0;
+  for (const lookup of pairLookups) {
+    const { first, second } = lookup.largest(reached);
+    kerning += first + second;
+  }
+
+  const { advance, glyphs } = largest;
+  const pixel = options.rounding === "pixel";
+  const float32 = options.sum === "float32" && !pixel;
+  // Pixel: an advance gets at most 1/128 px from the grid of 26.6, and then 0.5 px. A kerning sum gets at most 0.5 px
+  const pixelMargin = pixel ? 0.5 + 1 / 128 + (kerning > 0 ? 0.5 : 0) : 0;
+  // Float32: each lookup gives a glyph two positions, in units of 1/65536 px. A negative value gets no help from the relative
+  // factor below, so it has its own margin. The floor of a value and the round of a delta give 1 unit, the floor of the
+  // multiplier gives 0.5 units, and the cut of the scale gives KERNING_RANGE / unitsPerEm units to each of the two parts.
+  // The single precision gives FLOAT32 to the value and 4 FLOAT32 to the delta
+  const positions = pairLookups.length * 2;
+  const positionMargin = float32 ? (positions * (1.5 + (2 * KERNING_RANGE) / font.unitsPerEm)) / 65536 : 0;
+  const kerningMargin = float32 ? positions * 5 * FLOAT32 * KERNING_RANGE : 0;
+  return {
+    advance,
+    kerning,
+    glyphs,
+    width(length: number, size: number): number {
+      const total = length * ((advance + glyphs * (kerning + kerningMargin)) * (size / font.unitsPerEm) + glyphs * (pixelMargin + positionMargin));
+      // Float32: the fround of a glyph or 4 steps of a positive delta, the fround of a segment, and one step of the sum for
+      // each segment. A text has at most one segment for each UTF-16 unit
+      const single = float32 ? (1 + FLOAT32) ** (length + 6) : 1;
+      // The double precision: the scale and a few products, and one rounding for each step of a sum of fractions
+      return total * single * (1 + (2 ** 13 + length) * FLOAT64);
+    },
+  };
+}

package/src/fonts/font.ts

@@ -293,13 +293,29 @@ export function shapingWords(text: string): string[] {
   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: Font, options: MeasureOptions): { substitute: (word: string) => number[]; kerning: readonly PairLookup[] } {
+/** The choices that a set of options makes for the GSUB pass and for the kerning. */
+export interface Shaping {
+  readonly script: string;
+  /** The features of the option `features`, or `defaultFeatures`. */
+  readonly features: readonly string[];
+  readonly shaper: "indic" | "joining" | "plain";
+  readonly kerning: readonly PairLookup[];
+}
+
+/** This function gives the choices of a set of options: the script, the features, the shaper and the kerning lookups. */
+export function shapingOf(font: Font, options: MeasureOptions): Shaping {
   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 { substitute: indicShaper(font, script, features), kerning };
-  const joins = options.joining !== false && joiningScripts.includes(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: Font, options: MeasureOptions): { substitute: (word: string) => number[]; kerning: readonly PairLookup[] } {
+  const { script, features, shaper, kerning } = shapingOf(font, options);
+  if (shaper === "indic") return { substitute: indicShaper(font, script, features), kerning };
+  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, lookups: font.substitutions(script, stage.features) })) : [];
   const substitute = (word: string): number[] => {

package/src/fonts/index.ts

@@ -1,4 +1,5 @@
 export { readFont, measureWidth, glyphAdvances, shapingWords, type AdvanceSource, type Font, type ReadOptions, type MeasureOptions } from "./font.ts";
+export { widthBound, type WidthBound } from "./bound.ts";
 export { canvasSegments, canvasWords, isCjkIdeographOrSymbol } from "./words.ts";
 export { bidiLevels, visualOrder } from "./bidi.ts";
 export { indicScripts, indicShaper, indicSyllables, type IndicSyllableType } from "./indic.ts";

package/src/fonts/indic.ts

@@ -142,17 +142,7 @@ function vowelConstraints(codePoints: readonly number[]): number[] {
  */
 function normalize(codePoints: readonly number[], hasGlyph: (codePoint: number) => boolean): number[] {
   const allSimple = !codePoints.some((codePoint, i) => i > 0 && isMark(codePoint));
-  const decomposed: number[] = [];
-  for (const codePoint of codePoints) {
-    const parts = codePoint === 0x931 ? [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;
   // A stable sort of each run of marks with a class that is not 0
   for (let i = 1; i < decomposed.length; i++) {
@@ -180,6 +170,48 @@ function normalize(codePoints: readonly number[], hasGlyph: (codePoint: number)
   return out;
 }
 
+/** This function gives the code points of a character after the decomposition of `normalize`. */
+function decomposition(codePoint: number, hasGlyph: (codePoint: number) => boolean): number[] {
+  const parts = codePoint === 0x931 ? [codePoint] : [...String.fromCodePoint(codePoint).normalize("NFD")].map((part) => part.codePointAt(0)!);
+  return (parts.length > 1 || parts[0] !== codePoint) && parts.every(hasGlyph) ? parts : [codePoint];
+}
+
+/** The code points that `normalize` and `vowelConstraints` can give for a set of characters. */
+export interface IndicForms {
+  /** The parts of each character of the set after the decomposition. A character with no decomposition is its one part. */
+  readonly parts: ReadonlyMap<number, readonly number[]>;
+  /** The composites of each code point: the code points that it becomes when a mark composes with it. */
+  readonly composites: ReadonlyMap<number, readonly number[]>;
+  /** All the code points that the shaper can see: the set, its parts, the dotted circle and each composite. */
+  readonly codePoints: ReadonlySet<number>;
+}
+
+/**
+ * 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.
+ */
+export function indicForms(characters: ReadonlySet<number>, hasGlyph: (codePoint: number) => boolean): IndicForms {
+  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(0x25cc);
+  const composites = new Map<number, number[]>();
+  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 === undefined || !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: number, second: number): number | undefined {
   if (isMark(first)) return undefined;
@@ -288,6 +320,16 @@ const basicFeatures: readonly (readonly [string, boolean])[] = [
 ];
 /** The features of the last stage, after the final reordering. They match only in a syllable. */
 const finalFeatures: readonly string[] = ["init", "pres", "abvs", "blws", "psts", "haln"];
+/** This function gives the features of the page that the last stage applies. */
+function pageFeatures(features: readonly string[]): string[] {
+  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. */
+export function indicFeatures(features: readonly string[]): string[] {
+  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. */
@@ -352,8 +394,7 @@ export function indicShaper(font: Font, script: string, features: readonly strin
   };
   const first = lookupsOf(["locl", "ccmp"]);
   const basic = basicFeatures.map(([tag, global]) => ({ 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)),