@mark1russell7/typeset 0.0.0-bootstrap.0 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,23 @@
 # @mark1russell7/typeset
 
-This version is a placeholder. The release workflow of https://github.com/mark1russell7/typeset publishes the real versions. Use a later version.
+This package measures text and breaks it into lines. Each area has its own subpath.
+
+| Subpath | What it has |
+| --- | --- |
+| `@mark1russell7/typeset/breaking` | The paragraph model of boxes, glue and penalties, and the greedy, total fit and balanced line breakers. |
+
+## Line breaking
+
+```ts
+import { greedy, knuthPlass, linesOf, paragraphOf } from "@mark1russell7/typeset/breaking";
+
+const widthOf = (text: string): number => 8 * [...text].length;
+const paragraph = paragraphOf("The quick brown fox jumps over the lazy dog", { widthOf });
+const lines = linesOf(paragraph, knuthPlass.breaks(paragraph, 120));
+```
+
+- Each breaker takes any width function. The function gives the width of a run of text in any unit.
+- `greedy` fills each line as a browser does. `knuthPlass` chooses the breaks with the least sum of demerits. `balanced` keeps the greedy line count with more equal lines.
+- The option `hyphenate` gives the offsets of the hyphen breaks of a word.
+
+The repository [mark1russell7/typeset](https://github.com/mark1russell7/typeset) has the report of the breakers in `docs/BREAKING.md`.

package/build/breaking.d.ts

@@ -0,0 +1,2 @@
+import { C as lineWidth, S as lineStart, T as paragraphOf, _ as Paragraph, a as Breaker, b as WidthOf, c as balancedBreaker, d as knuthPlass, f as totalFit, g as Line, h as Item, i as BalancedOptions, l as breakers, m as Glue, n as raggedness, o as TotalFitOptions, p as Box, r as spread, s as balanced, u as greedy, v as ParagraphOptions, w as linesOf, x as isBreak, y as Penalty } from "./chunks/breaking.js";
+export { type BalancedOptions, type Box, type Breaker, type Glue, type Item, type Line, type Paragraph, type ParagraphOptions, type Penalty, type TotalFitOptions, type WidthOf, balanced, balancedBreaker, breakers, greedy, isBreak, knuthPlass, lineStart, lineWidth, linesOf, paragraphOf, raggedness, spread, totalFit };

package/build/breaking.js

@@ -0,0 +1 @@
+export { i as balanced, a as balancedBreaker, o as breakers, s as greedy, u as isBreak, c as knuthPlass, d as lineStart, f as lineWidth, p as linesOf, m as paragraphOf, n as raggedness, r as spread, l as totalFit } from "./chunks/breaking.js";

package/build/chunks/breaking.d.ts

@@ -0,0 +1,130 @@
+/**
+ * The paragraph model of the breakers: a list of boxes, glue and penalties, as Knuth and Plass define it. A builder makes
+ * the items of a text. The breakers read only the items, so a new rule of break opportunities is a new builder.
+ */
+/** A width function: the width of a run of text, in any unit. The breakers add the widths and compare them. */
+type WidthOf = (text: string) => number;
+/** A box: text that the breaker does not break. */
+interface Box {
+  readonly type: "box";
+  readonly text: string;
+  readonly width: number;
+}
+/** Glue: a space between two boxes. A line can end at glue that comes after a box. The line then does not show the glue. */
+interface Glue {
+  readonly type: "glue";
+  readonly text: string;
+  readonly width: number;
+}
+/**
+ * A penalty: a break opportunity with a cost. A line that ends at the penalty shows its text, for example a hyphen. A cost of
+ * `Infinity` forbids the break, and a cost of `-Infinity` forces it.
+ */
+interface Penalty {
+  readonly type: "penalty";
+  readonly text: string;
+  readonly width: number;
+  readonly cost: number;
+  /** A flagged penalty is a hyphen. Total fit adds a cost to two flagged breaks in sequence. */
+  readonly flagged: boolean;
+}
+/** An item of a paragraph. */
+type Item = Box | Glue | Penalty;
+/** A paragraph: the items in the order of the text. */
+interface Paragraph {
+  readonly items: readonly Item[];
+}
+/** The options of `paragraphOf`. */
+interface ParagraphOptions {
+  /** The width function of the boxes, the spaces and the hyphens. */
+  readonly widthOf: WidthOf;
+  /**
+   * The hyphenation hook. It gives the offsets in a word where a break with a hyphen is possible. The default gives no
+   * offset. The width of each part of a word comes from `widthOf`, so the kerning across an offset is not in the sum.
+   */
+  readonly hyphenate?: (word: string) => readonly number[];
+  /** The text that a line shows at a hyphen break. The default is "-". */
+  readonly hyphen?: string;
+  /** The cost of a hyphen break. The default is 50, as in TeX. */
+  readonly hyphenCost?: number;
+}
+/**
+ * This function makes the paragraph of a text with the break opportunities of CSS `white-space: normal`. Each run of white
+ * space becomes one glue of the width of a space. Each word between two runs becomes a box, or boxes and hyphen penalties.
+ */
+declare function paragraphOf(text: string, options: ParagraphOptions): Paragraph;
+/** A line of a broken paragraph. */
+interface Line {
+  readonly text: string;
+  /** The width of the line: its boxes, the glue between them and the text of a penalty at its end. */
+  readonly width: number;
+  /** The index of the first item of the line. */
+  readonly start: number;
+  /** The index after the last item of the line. A break at glue or at a penalty has the index of that item. */
+  readonly end: number;
+}
+/** This function tells if a line can end at the item `index`: glue after a box, or a penalty with a cost below `Infinity`. */
+declare function isBreak(items: readonly Item[], index: number): boolean;
+/** This function gives the index of the first item of a line after a break at `index`. It skips the glue and the penalties. */
+declare function lineStart(items: readonly Item[], index: number): number;
+/** This function gives the width of the line from the item `start` to a break at `end`, with the text of a penalty at `end`. */
+declare function lineWidth(items: readonly Item[], start: number, end: number): number;
+/**
+ * This function gives the lines of a paragraph from the indices of its breaks. Each break is the index of glue or of a penalty.
+ * The last line ends at the end of the items.
+ */
+declare function linesOf(paragraph: Paragraph, breaks: readonly number[]): Line[];
+/**
+ * A breaker: a strategy that chooses the breaks of a paragraph for the line width `width`. It gives the indices of the
+ * items where the lines end, in order. A breaker reads only the items, so any width function and any builder work with it.
+ */
+interface Breaker {
+  readonly name: string;
+  breaks(paragraph: Paragraph, width: number): number[];
+}
+/**
+ * The greedy breaker: first fit, as a browser with `text-wrap: wrap`. Each line takes the items while they fit in the width.
+ * A box that is wider than a line stays whole on its own line.
+ */
+declare const greedy: Breaker;
+/** The options of the total fit breaker. */
+interface TotalFitOptions {
+  /** The cost of each line, as `\linepenalty` of TeX. A larger value gives fewer lines. The default is 10. */
+  readonly linePenalty?: number;
+  /** The cost of two hyphen breaks in sequence. The default is 3000, as `\doublehyphendemerits` of TeX. */
+  readonly flaggedCost?: number;
+}
+/**
+ * This function gives the total fit breaker of Knuth and Plass for text with a ragged right edge. It chooses the breaks with
+ * the least sum of demerits over all the lines. The demerits of a line are `(linePenalty + 100 r²)²` plus the square of the
+ * cost of its penalty. The ratio `r` is the free space of the line divided by the width. The last line has `r = 0`.
+ */
+declare function totalFit(options?: TotalFitOptions): Breaker;
+/** The total fit breaker with the default options. */
+declare const knuthPlass: Breaker;
+/** The options of the balanced breaker. */
+interface BalancedOptions {
+  /** The steps of the search for the width. The default is 32. */
+  readonly steps?: number;
+}
+/**
+ * This function gives the balanced breaker, as a browser with `text-wrap: balance`. It keeps the line count of the greedy
+ * breaker, and it finds the least width that gives that count. Thus the lines have more equal widths.
+ */
+declare function balancedBreaker(options?: BalancedOptions): Breaker;
+/** The balanced breaker with the default options. */
+declare const balanced: Breaker;
+/** The breakers of the package, by name. */
+declare const breakers: Readonly<Record<"greedy" | "total-fit" | "balanced", Breaker>>;
+/**
+ * This function gives the raggedness of the lines for the width `width`: the mean of `((width - line) / width)²` over the
+ * lines before the last line. It is 0 for one line. `@mark1russell7/layout-contract/text` uses the same measure.
+ */
+declare function raggedness(lines: readonly Line[], width: number): number;
+/** This function gives the spread of the lines: the width of the widest line less the width of the narrowest line, the last line included. */
+declare function spread(lines: readonly Line[]): number;
+declare namespace breaking_d_exports {
+  export { BalancedOptions, Box, Breaker, Glue, Item, Line, Paragraph, ParagraphOptions, Penalty, TotalFitOptions, WidthOf, balanced, balancedBreaker, breakers, greedy, isBreak, knuthPlass, lineStart, lineWidth, linesOf, paragraphOf, raggedness, spread, totalFit };
+}
+export { lineWidth as C, lineStart as S, paragraphOf as T, Paragraph as _, Breaker as a, WidthOf as b, balancedBreaker as c, knuthPlass as d, totalFit as f, Line as g, Item as h, BalancedOptions as i, breakers as l, Glue as m, raggedness as n, TotalFitOptions as o, Box as p, spread as r, balanced as s, breaking_d_exports as t, greedy as u, ParagraphOptions as v, linesOf as w, isBreak as x, Penalty as y };
+//# sourceMappingURL=breaking.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"breaking.d.ts","names":[],"sources":["../../src/breaking/paragraph.ts","../../src/breaking/breakers.ts","../../src/breaking/measures.ts","../../src/breaking.ts"],"mappings":";;;;;KAMY,WAAW;;UAGN;WACN;WACA;WACA;;;UAIM;WACN;WACA;WACA;;;;;;UAOM;WACN;WACA;WACA;WACA;;WAEA;;;KAIC,OAAO,MAAM,OAAO;;UAGf;WACN,gBAAgB;;;UAIV;;WAEN,SAAS;;;;;WAKT,aAAa;;WAEb;;WAEA;;;;;;iBASK,YAAY,cAAc,SAAS,mBAAmB;;UAyBrD;WACN;;WAEA;;WAEA;;WAEA;;;iBAIK,QAAQ,gBAAgB,QAAQ;;iBAOhC,UAAU,gBAAgB,QAAQ;;iBAOlC,UAAU,gBAAgB,QAAQ,eAAe;;;;;iBAcjD,QAAQ,WAAW,WAAW,4BAA4B;;;;;UC1HzD;WACN;EACT,OAAO,WAAW,WAAW;;;;;;cAOlB,QAAQ;;UAsCJ;;WAEN;;WAEA;;;;;;;iBAQK,SAAS,UAAS,kBAAuB;;cAU5C,YAAY;;UAsDR;;WAEN;;;;;;iBAOK,gBAAgB,UAAS,kBAAuB;;cAmBnD,UAAU;;cAGV,UAAU,SAAS,4CAA4C;;;;;iBC1J5D,WAAW,gBAAgB,QAAQ;;iBAWnC,OAAO,gBAAgB"}

package/build/chunks/breaking.js

@@ -0,0 +1,267 @@
+import { t as __exportAll } from "./rolldown-runtime.js";
+// src/breaking/paragraph.ts
+const whiteSpace = /\s+/u;
+/**
+* This function makes the paragraph of a text with the break opportunities of CSS `white-space: normal`. Each run of white
+* space becomes one glue of the width of a space. Each word between two runs becomes a box, or boxes and hyphen penalties.
+*/
+function paragraphOf(text, options) {
+	const { widthOf } = options;
+	const hyphen = options.hyphen ?? "-";
+	const hyphenCost = options.hyphenCost ?? 50;
+	const space = widthOf(" ");
+	const hyphenWidth = options.hyphenate === void 0 ? 0 : widthOf(hyphen);
+	const items = [];
+	for (const word of text.split(whiteSpace)) {
+		if (word === "") continue;
+		if (items.length > 0) items.push({
+			type: "glue",
+			text: " ",
+			width: space
+		});
+		const offsets = options.hyphenate === void 0 ? [] : [...new Set(options.hyphenate(word))].filter((o) => o > 0 && o < word.length).sort((a, b) => a - b);
+		let start = 0;
+		for (const offset of offsets) {
+			const part = word.slice(start, offset);
+			items.push({
+				type: "box",
+				text: part,
+				width: widthOf(part)
+			});
+			items.push({
+				type: "penalty",
+				text: hyphen,
+				width: hyphenWidth,
+				cost: hyphenCost,
+				flagged: true
+			});
+			start = offset;
+		}
+		const last = word.slice(start);
+		items.push({
+			type: "box",
+			text: last,
+			width: widthOf(last)
+		});
+	}
+	return { items };
+}
+/** This function tells if a line can end at the item `index`: glue after a box, or a penalty with a cost below `Infinity`. */
+function isBreak(items, index) {
+	const item = items[index];
+	if (item.type === "glue") return index > 0 && items[index - 1].type === "box";
+	return item.type === "penalty" && item.cost < Infinity;
+}
+/** This function gives the index of the first item of a line after a break at `index`. It skips the glue and the penalties. */
+function lineStart(items, index) {
+	let i = index + 1;
+	while (i < items.length && items[i].type !== "box") i++;
+	return i;
+}
+/** This function gives the width of the line from the item `start` to a break at `end`, with the text of a penalty at `end`. */
+function lineWidth(items, start, end) {
+	let width = 0;
+	for (let i = start; i < end; i++) {
+		const item = items[i];
+		if (item.type !== "penalty") width += item.width;
+	}
+	const last = items[end];
+	return last?.type === "penalty" ? width + last.width : width;
+}
+/**
+* This function gives the lines of a paragraph from the indices of its breaks. Each break is the index of glue or of a penalty.
+* The last line ends at the end of the items.
+*/
+function linesOf(paragraph, breaks) {
+	const { items } = paragraph;
+	const lines = [];
+	let start = 0;
+	for (const end of [...breaks, items.length]) {
+		let text = "";
+		for (let i = start; i < end; i++) {
+			const item = items[i];
+			if (item.type !== "penalty") text += item.text;
+		}
+		const last = items[end];
+		if (last?.type === "penalty") text += last.text;
+		lines.push({
+			text,
+			width: lineWidth(items, start, end),
+			start,
+			end
+		});
+		start = lineStart(items, end);
+	}
+	return lines;
+}
+// src/breaking/breakers.ts
+/**
+* The greedy breaker: first fit, as a browser with `text-wrap: wrap`. Each line takes the items while they fit in the width.
+* A box that is wider than a line stays whole on its own line.
+*/
+const greedy = {
+	name: "greedy",
+	breaks: (paragraph, width) => greedyBreaks(paragraph, width)
+};
+/**
+* This function gives the breaks of the greedy breaker. After each break, it reads the items again from the start of the new
+* line, so that each break opportunity of the new line counts.
+*/
+function greedyBreaks(paragraph, width) {
+	const { items } = paragraph;
+	const breaks = [];
+	let used = 0;
+	let candidate = -1;
+	const breakAt = (index) => {
+		breaks.push(index);
+		used = 0;
+		candidate = -1;
+		return lineStart(items, index) - 1;
+	};
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		if (item.type === "box") {
+			used += item.width;
+			if (used > width && candidate >= 0) i = breakAt(candidate);
+		} else if (item.type === "penalty" && item.cost === -Infinity) i = breakAt(i);
+		else if (item.type === "glue") {
+			if (isBreak(items, i)) candidate = i;
+			used += item.width;
+		} else if (isBreak(items, i) && used + item.width <= width) candidate = i;
+	}
+	return breaks;
+}
+/**
+* This function gives the total fit breaker of Knuth and Plass for text with a ragged right edge. It chooses the breaks with
+* the least sum of demerits over all the lines. The demerits of a line are `(linePenalty + 100 r²)²` plus the square of the
+* cost of its penalty. The ratio `r` is the free space of the line divided by the width. The last line has `r = 0`.
+*/
+function totalFit(options = {}) {
+	const linePenalty = options.linePenalty ?? 10;
+	const flaggedCost = options.flaggedCost ?? 3e3;
+	return {
+		name: "total-fit",
+		breaks: (paragraph, width) => totalFitBreaks(paragraph, width, linePenalty, flaggedCost)
+	};
+}
+/** The total fit breaker with the default options. */
+const knuthPlass = totalFit();
+/** This function gives the breaks of the total fit breaker, by dynamic programming over the break opportunities. */
+function totalFitBreaks(paragraph, width, linePenalty, flaggedCost) {
+	const { items } = paragraph;
+	const nodes = [-1];
+	for (let i = 0; i < items.length; i++) if (isBreak(items, i)) nodes.push(i);
+	nodes.push(items.length);
+	const best = new Array(nodes.length).fill(Infinity);
+	const previous = new Array(nodes.length).fill(-1);
+	best[0] = 0;
+	for (let a = 0; a < nodes.length - 1; a++) {
+		if (best[a] === Infinity) continue;
+		const start = a === 0 ? 0 : lineStart(items, nodes[a]);
+		const flaggedBefore = a > 0 && isFlagged(paragraph, nodes[a]);
+		for (let b = a + 1; b < nodes.length; b++) {
+			const end = nodes[b];
+			const last = b === nodes.length - 1;
+			const used = lineWidth(items, start, end);
+			const overflow = used > width;
+			if (overflow && b > a + 1) {
+				if (items[end]?.type === "penalty") continue;
+				break;
+			}
+			const penalty = items[end];
+			const cost = penalty?.type === "penalty" ? penalty.cost : 0;
+			const ratio = last || overflow ? 0 : (width - used) / width;
+			let demerits = (linePenalty + 100 * ratio * ratio) ** 2;
+			if (cost > 0) demerits += cost * cost;
+			else if (cost > -Infinity && cost < 0) demerits -= cost * cost;
+			if (flaggedBefore && isFlagged(paragraph, end)) demerits += flaggedCost;
+			const total = best[a] + demerits;
+			if (total < best[b]) {
+				best[b] = total;
+				previous[b] = a;
+			}
+			if (cost === -Infinity) break;
+		}
+	}
+	const breaks = [];
+	for (let b = previous[nodes.length - 1]; b > 0; b = previous[b]) breaks.push(nodes[b]);
+	return breaks.reverse();
+}
+/** This function tells if the item `index` is a flagged penalty. */
+function isFlagged(paragraph, index) {
+	const item = paragraph.items[index];
+	return item?.type === "penalty" && item.flagged;
+}
+/**
+* This function gives the balanced breaker, as a browser with `text-wrap: balance`. It keeps the line count of the greedy
+* breaker, and it finds the least width that gives that count. Thus the lines have more equal widths.
+*/
+function balancedBreaker(options = {}) {
+	const steps = options.steps ?? 32;
+	return {
+		name: "balanced",
+		breaks: (paragraph, width) => {
+			const count = greedyBreaks(paragraph, width).length;
+			let low = 0;
+			let high = width;
+			for (let step = 0; step < steps; step++) {
+				const middle = (low + high) / 2;
+				if (greedyBreaks(paragraph, middle).length === count) high = middle;
+				else low = middle;
+			}
+			return greedyBreaks(paragraph, high);
+		}
+	};
+}
+/** The balanced breaker with the default options. */
+const balanced = balancedBreaker();
+/** The breakers of the package, by name. */
+const breakers = {
+	greedy,
+	"total-fit": knuthPlass,
+	balanced
+};
+// src/breaking/measures.ts
+/**
+* This function gives the raggedness of the lines for the width `width`: the mean of `((width - line) / width)²` over the
+* lines before the last line. It is 0 for one line. `@mark1russell7/layout-contract/text` uses the same measure.
+*/
+function raggedness(lines, width) {
+	if (lines.length < 2) return 0;
+	let sum = 0;
+	for (let i = 0; i < lines.length - 1; i++) {
+		const free = (width - lines[i].width) / width;
+		sum += free * free;
+	}
+	return sum / (lines.length - 1);
+}
+/** This function gives the spread of the lines: the width of the widest line less the width of the narrowest line, the last line included. */
+function spread(lines) {
+	if (lines.length === 0) return 0;
+	let widest = -Infinity;
+	let narrowest = Infinity;
+	for (const line of lines) {
+		widest = Math.max(widest, line.width);
+		narrowest = Math.min(narrowest, line.width);
+	}
+	return widest - narrowest;
+}
+// src/breaking.ts
+var breaking_exports = /* @__PURE__ */ __exportAll({
+	balanced: () => balanced,
+	balancedBreaker: () => balancedBreaker,
+	breakers: () => breakers,
+	greedy: () => greedy,
+	isBreak: () => isBreak,
+	knuthPlass: () => knuthPlass,
+	lineStart: () => lineStart,
+	lineWidth: () => lineWidth,
+	linesOf: () => linesOf,
+	paragraphOf: () => paragraphOf,
+	raggedness: () => raggedness,
+	spread: () => spread,
+	totalFit: () => totalFit
+});
+export { balancedBreaker as a, knuthPlass as c, lineStart as d, lineWidth as f, balanced as i, totalFit as l, paragraphOf as m, raggedness as n, breakers as o, linesOf as p, spread as r, greedy as s, breaking_exports as t, isBreak as u };
+
+//# sourceMappingURL=breaking.js.map

package/build/chunks/breaking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"breaking.js","names":[],"sources":["../../src/breaking/paragraph.ts","../../src/breaking/breakers.ts","../../src/breaking/measures.ts","../../src/breaking.ts"],"sourcesContent":["/**\n * The paragraph model of the breakers: a list of boxes, glue and penalties, as Knuth and Plass define it. A builder makes\n * the items of a text. The breakers read only the items, so a new rule of break opportunities is a new builder.\n */\n\n/** A width function: the width of a run of text, in any unit. The breakers add the widths and compare them. */\nexport type WidthOf = (text: string) => number;\n\n/** A box: text that the breaker does not break. */\nexport interface Box {\n  readonly type: \"box\";\n  readonly text: string;\n  readonly width: number;\n}\n\n/** Glue: a space between two boxes. A line can end at glue that comes after a box. The line then does not show the glue. */\nexport interface Glue {\n  readonly type: \"glue\";\n  readonly text: string;\n  readonly width: number;\n}\n\n/**\n * A penalty: a break opportunity with a cost. A line that ends at the penalty shows its text, for example a hyphen. A cost of\n * `Infinity` forbids the break, and a cost of `-Infinity` forces it.\n */\nexport interface Penalty {\n  readonly type: \"penalty\";\n  readonly text: string;\n  readonly width: number;\n  readonly cost: number;\n  /** A flagged penalty is a hyphen. Total fit adds a cost to two flagged breaks in sequence. */\n  readonly flagged: boolean;\n}\n\n/** An item of a paragraph. */\nexport type Item = Box | Glue | Penalty;\n\n/** A paragraph: the items in the order of the text. */\nexport interface Paragraph {\n  readonly items: readonly Item[];\n}\n\n/** The options of `paragraphOf`. */\nexport interface ParagraphOptions {\n  /** The width function of the boxes, the spaces and the hyphens. */\n  readonly widthOf: WidthOf;\n  /**\n   * The hyphenation hook. It gives the offsets in a word where a break with a hyphen is possible. The default gives no\n   * offset. The width of each part of a word comes from `widthOf`, so the kerning across an offset is not in the sum.\n   */\n  readonly hyphenate?: (word: string) => readonly number[];\n  /** The text that a line shows at a hyphen break. The default is \"-\". */\n  readonly hyphen?: string;\n  /** The cost of a hyphen break. The default is 50, as in TeX. */\n  readonly hyphenCost?: number;\n}\n\nconst whiteSpace = /\\s+/u;\n\n/**\n * This function makes the paragraph of a text with the break opportunities of CSS `white-space: normal`. Each run of white\n * space becomes one glue of the width of a space. Each word between two runs becomes a box, or boxes and hyphen penalties.\n */\nexport function paragraphOf(text: string, options: ParagraphOptions): Paragraph {\n  const { widthOf } = options;\n  const hyphen = options.hyphen ?? \"-\";\n  const hyphenCost = options.hyphenCost ?? 50;\n  const space = widthOf(\" \");\n  const hyphenWidth = options.hyphenate === undefined ? 0 : widthOf(hyphen);\n  const items: Item[] = [];\n  for (const word of text.split(whiteSpace)) {\n    if (word === \"\") continue;\n    if (items.length > 0) items.push({ type: \"glue\", text: \" \", width: space });\n    const offsets = options.hyphenate === undefined ? [] : [...new Set(options.hyphenate(word))].filter((o) => o > 0 && o < word.length).sort((a, b) => a - b);\n    let start = 0;\n    for (const offset of offsets) {\n      const part = word.slice(start, offset);\n      items.push({ type: \"box\", text: part, width: widthOf(part) });\n      items.push({ type: \"penalty\", text: hyphen, width: hyphenWidth, cost: hyphenCost, flagged: true });\n      start = offset;\n    }\n    const last = word.slice(start);\n    items.push({ type: \"box\", text: last, width: widthOf(last) });\n  }\n  return { items };\n}\n\n/** A line of a broken paragraph. */\nexport interface Line {\n  readonly text: string;\n  /** The width of the line: its boxes, the glue between them and the text of a penalty at its end. */\n  readonly width: number;\n  /** The index of the first item of the line. */\n  readonly start: number;\n  /** The index after the last item of the line. A break at glue or at a penalty has the index of that item. */\n  readonly end: number;\n}\n\n/** This function tells if a line can end at the item `index`: glue after a box, or a penalty with a cost below `Infinity`. */\nexport function isBreak(items: readonly Item[], index: number): boolean {\n  const item = items[index]!;\n  if (item.type === \"glue\") return index > 0 && items[index - 1]!.type === \"box\";\n  return item.type === \"penalty\" && item.cost < Infinity;\n}\n\n/** This function gives the index of the first item of a line after a break at `index`. It skips the glue and the penalties. */\nexport function lineStart(items: readonly Item[], index: number): number {\n  let i = index + 1;\n  while (i < items.length && items[i]!.type !== \"box\") i++;\n  return i;\n}\n\n/** This function gives the width of the line from the item `start` to a break at `end`, with the text of a penalty at `end`. */\nexport function lineWidth(items: readonly Item[], start: number, end: number): number {\n  let width = 0;\n  for (let i = start; i < end; i++) {\n    const item = items[i]!;\n    if (item.type !== \"penalty\") width += item.width;\n  }\n  const last = items[end];\n  return last?.type === \"penalty\" ? width + last.width : width;\n}\n\n/**\n * This function gives the lines of a paragraph from the indices of its breaks. Each break is the index of glue or of a penalty.\n * The last line ends at the end of the items.\n */\nexport function linesOf(paragraph: Paragraph, breaks: readonly number[]): Line[] {\n  const { items } = paragraph;\n  const lines: Line[] = [];\n  let start = 0;\n  for (const end of [...breaks, items.length]) {\n    let text = \"\";\n    for (let i = start; i < end; i++) {\n      const item = items[i]!;\n      if (item.type !== \"penalty\") text += item.text;\n    }\n    const last = items[end];\n    if (last?.type === \"penalty\") text += last.text;\n    lines.push({ text, width: lineWidth(items, start, end), start, end });\n    start = lineStart(items, end);\n  }\n  return lines;\n}\n","import { isBreak, lineStart, lineWidth, type Paragraph } from \"./paragraph.ts\";\n\n/**\n * A breaker: a strategy that chooses the breaks of a paragraph for the line width `width`. It gives the indices of the\n * items where the lines end, in order. A breaker reads only the items, so any width function and any builder work with it.\n */\nexport interface Breaker {\n  readonly name: string;\n  breaks(paragraph: Paragraph, width: number): number[];\n}\n\n/**\n * The greedy breaker: first fit, as a browser with `text-wrap: wrap`. Each line takes the items while they fit in the width.\n * A box that is wider than a line stays whole on its own line.\n */\nexport const greedy: Breaker = {\n  name: \"greedy\",\n  breaks: (paragraph, width) => greedyBreaks(paragraph, width),\n};\n\n/**\n * This function gives the breaks of the greedy breaker. After each break, it reads the items again from the start of the new\n * line, so that each break opportunity of the new line counts.\n */\nfunction greedyBreaks(paragraph: Paragraph, width: number): number[] {\n  const { items } = paragraph;\n  const breaks: number[] = [];\n  let used = 0;\n  let candidate = -1;\n  const breakAt = (index: number): number => {\n    breaks.push(index);\n    used = 0;\n    candidate = -1;\n    return lineStart(items, index) - 1;\n  };\n  for (let i = 0; i < items.length; i++) {\n    const item = items[i]!;\n    if (item.type === \"box\") {\n      used += item.width;\n      if (used > width && candidate >= 0) i = breakAt(candidate);\n    } else if (item.type === \"penalty\" && item.cost === -Infinity) {\n      i = breakAt(i);\n    } else if (item.type === \"glue\") {\n      if (isBreak(items, i)) candidate = i;\n      used += item.width;\n    } else if (isBreak(items, i) && used + item.width <= width) {\n      candidate = i;\n    }\n  }\n  return breaks;\n}\n\n/** The options of the total fit breaker. */\nexport interface TotalFitOptions {\n  /** The cost of each line, as `\\linepenalty` of TeX. A larger value gives fewer lines. The default is 10. */\n  readonly linePenalty?: number;\n  /** The cost of two hyphen breaks in sequence. The default is 3000, as `\\doublehyphendemerits` of TeX. */\n  readonly flaggedCost?: number;\n}\n\n/**\n * This function gives the total fit breaker of Knuth and Plass for text with a ragged right edge. It chooses the breaks with\n * the least sum of demerits over all the lines. The demerits of a line are `(linePenalty + 100 r²)²` plus the square of the\n * cost of its penalty. The ratio `r` is the free space of the line divided by the width. The last line has `r = 0`.\n */\nexport function totalFit(options: TotalFitOptions = {}): Breaker {\n  const linePenalty = options.linePenalty ?? 10;\n  const flaggedCost = options.flaggedCost ?? 3000;\n  return {\n    name: \"total-fit\",\n    breaks: (paragraph, width) => totalFitBreaks(paragraph, width, linePenalty, flaggedCost),\n  };\n}\n\n/** The total fit breaker with the default options. */\nexport const knuthPlass: Breaker = totalFit();\n\n/** This function gives the breaks of the total fit breaker, by dynamic programming over the break opportunities. */\nfunction totalFitBreaks(paragraph: Paragraph, width: number, linePenalty: number, flaggedCost: number): number[] {\n  const { items } = paragraph;\n  // The nodes: the start of the paragraph (-1), each break opportunity, and the end (items.length)\n  const nodes = [-1];\n  for (let i = 0; i < items.length; i++) if (isBreak(items, i)) nodes.push(i);\n  nodes.push(items.length);\n  const best = new Array<number>(nodes.length).fill(Infinity);\n  const previous = new Array<number>(nodes.length).fill(-1);\n  best[0] = 0;\n  for (let a = 0; a < nodes.length - 1; a++) {\n    if (best[a] === Infinity) continue;\n    const start = a === 0 ? 0 : lineStart(items, nodes[a]!);\n    const flaggedBefore = a > 0 && isFlagged(paragraph, nodes[a]!);\n    for (let b = a + 1; b < nodes.length; b++) {\n      const end = nodes[b]!;\n      const last = b === nodes.length - 1;\n      const used = lineWidth(items, start, end);\n      const overflow = used > width;\n      // A line wider than the width is possible only when no break opportunity is inside it\n      if (overflow && b > a + 1) {\n        if (items[end]?.type === \"penalty\") continue;\n        break;\n      }\n      const penalty = items[end];\n      const cost = penalty?.type === \"penalty\" ? penalty.cost : 0;\n      const ratio = last || overflow ? 0 : (width - used) / width;\n      let demerits = (linePenalty + 100 * ratio * ratio) ** 2;\n      if (cost > 0) demerits += cost * cost;\n      else if (cost > -Infinity && cost < 0) demerits -= cost * cost;\n      if (flaggedBefore && isFlagged(paragraph, end)) demerits += flaggedCost;\n      const total = best[a]! + demerits;\n      if (total < best[b]!) {\n        best[b] = total;\n        previous[b] = a;\n      }\n      // A forced break ends each line that comes to it\n      if (cost === -Infinity) break;\n    }\n  }\n  const breaks: number[] = [];\n  for (let b = previous[nodes.length - 1]!; b > 0; b = previous[b]!) breaks.push(nodes[b]!);\n  return breaks.reverse();\n}\n\n/** This function tells if the item `index` is a flagged penalty. */\nfunction isFlagged(paragraph: Paragraph, index: number): boolean {\n  const item = paragraph.items[index];\n  return item?.type === \"penalty\" && item.flagged;\n}\n\n/** The options of the balanced breaker. */\nexport interface BalancedOptions {\n  /** The steps of the search for the width. The default is 32. */\n  readonly steps?: number;\n}\n\n/**\n * This function gives the balanced breaker, as a browser with `text-wrap: balance`. It keeps the line count of the greedy\n * breaker, and it finds the least width that gives that count. Thus the lines have more equal widths.\n */\nexport function balancedBreaker(options: BalancedOptions = {}): Breaker {\n  const steps = options.steps ?? 32;\n  return {\n    name: \"balanced\",\n    breaks: (paragraph, width) => {\n      const count = greedyBreaks(paragraph, width).length;\n      let low = 0;\n      let high = width;\n      for (let step = 0; step < steps; step++) {\n        const middle = (low + high) / 2;\n        if (greedyBreaks(paragraph, middle).length === count) high = middle;\n        else low = middle;\n      }\n      return greedyBreaks(paragraph, high);\n    },\n  };\n}\n\n/** The balanced breaker with the default options. */\nexport const balanced: Breaker = balancedBreaker();\n\n/** The breakers of the package, by name. */\nexport const breakers: Readonly<Record<\"greedy\" | \"total-fit\" | \"balanced\", Breaker>> = { greedy, \"total-fit\": knuthPlass, balanced };\n","import type { Line } from \"./paragraph.ts\";\n\n/**\n * This function gives the raggedness of the lines for the width `width`: the mean of `((width - line) / width)²` over the\n * lines before the last line. It is 0 for one line. `@mark1russell7/layout-contract/text` uses the same measure.\n */\nexport function raggedness(lines: readonly Line[], width: number): number {\n  if (lines.length < 2) return 0;\n  let sum = 0;\n  for (let i = 0; i < lines.length - 1; i++) {\n    const free = (width - lines[i]!.width) / width;\n    sum += free * free;\n  }\n  return sum / (lines.length - 1);\n}\n\n/** This function gives the spread of the lines: the width of the widest line less the width of the narrowest line, the last line included. */\nexport function spread(lines: readonly Line[]): number {\n  if (lines.length === 0) return 0;\n  let widest = -Infinity;\n  let narrowest = Infinity;\n  for (const line of lines) {\n    widest = Math.max(widest, line.width);\n    narrowest = Math.min(narrowest, line.width);\n  }\n  return widest - narrowest;\n}\n","export { balanced, balancedBreaker, breakers, greedy, knuthPlass, totalFit, type BalancedOptions, type Breaker, type TotalFitOptions } from \"./breaking/breakers.ts\";\nexport { raggedness, spread } from \"./breaking/measures.ts\";\nexport { isBreak, lineStart, lineWidth, linesOf, paragraphOf, type Box, type Glue, type Item, type Line, type Paragraph, type ParagraphOptions, type Penalty, type WidthOf } from \"./breaking/paragraph.ts\";\n"],"mappings":"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"}

package/build/chunks/rolldown-runtime.js

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll as t };

package/build/index.d.ts

@@ -0,0 +1,2 @@
+import { t as breaking_d_exports } from "./chunks/breaking.js";
+export { breaking_d_exports as breaking };

package/build/index.js

@@ -0,0 +1 @@
+export { t as breaking } from "./chunks/breaking.js";

package/package.json

@@ -1,13 +1,66 @@
 {
+  "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/typeset",
-  "version": "0.0.0-bootstrap.0",
-  "description": "A placeholder that lets npm trust the release workflow of mark1russell7/typeset. Use a later version.",
+  "version": "0.1.0",
+  "description": "Text measurement and line breaking. The subpath ./breaking has the greedy, total fit and balanced line breakers, for any width function.",
+  "keywords": [
+    "typeset",
+    "line-breaking",
+    "knuth-plass",
+    "text-layout",
+    "typescript"
+  ],
+  "homepage": "https://github.com/mark1russell7/typeset#readme",
+  "bugs": {
+    "url": "https://github.com/mark1russell7/typeset/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mark1russell7/typeset.git"
+    "url": "git+https://github.com/mark1russell7/typeset.git",
+    "directory": "packages/typeset"
   },
   "license": "MIT",
+  "author": "Mark Russell (https://github.com/mark1russell7)",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/index.d.ts",
+      "default": "./build/index.js"
+    },
+    "./breaking": {
+      "types": "./build/breaking.d.ts",
+      "default": "./build/breaking.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "build",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/report.ts"
+  ],
+  "engines": {
+    "node": ">=22.12"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@mark1russell7/cue": "^1.0.2",
+    "@mark1russell7/layout-contract": "^0.2.21",
+    "@types/node": "^26.6.5",
+    "@typeset/corpus": "0.1.0",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json"
   }
-}
+}

package/src/breaking/breakers.ts

@@ -0,0 +1,161 @@
+import { isBreak, lineStart, lineWidth, type Paragraph } from "./paragraph.ts";
+
+/**
+ * A breaker: a strategy that chooses the breaks of a paragraph for the line width `width`. It gives the indices of the
+ * items where the lines end, in order. A breaker reads only the items, so any width function and any builder work with it.
+ */
+export interface Breaker {
+  readonly name: string;
+  breaks(paragraph: Paragraph, width: number): number[];
+}
+
+/**
+ * The greedy breaker: first fit, as a browser with `text-wrap: wrap`. Each line takes the items while they fit in the width.
+ * A box that is wider than a line stays whole on its own line.
+ */
+export const greedy: Breaker = {
+  name: "greedy",
+  breaks: (paragraph, width) => greedyBreaks(paragraph, width),
+};
+
+/**
+ * This function gives the breaks of the greedy breaker. After each break, it reads the items again from the start of the new
+ * line, so that each break opportunity of the new line counts.
+ */
+function greedyBreaks(paragraph: Paragraph, width: number): number[] {
+  const { items } = paragraph;
+  const breaks: number[] = [];
+  let used = 0;
+  let candidate = -1;
+  const breakAt = (index: number): number => {
+    breaks.push(index);
+    used = 0;
+    candidate = -1;
+    return lineStart(items, index) - 1;
+  };
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i]!;
+    if (item.type === "box") {
+      used += item.width;
+      if (used > width && candidate >= 0) i = breakAt(candidate);
+    } else if (item.type === "penalty" && item.cost === -Infinity) {
+      i = breakAt(i);
+    } else if (item.type === "glue") {
+      if (isBreak(items, i)) candidate = i;
+      used += item.width;
+    } else if (isBreak(items, i) && used + item.width <= width) {
+      candidate = i;
+    }
+  }
+  return breaks;
+}
+
+/** The options of the total fit breaker. */
+export interface TotalFitOptions {
+  /** The cost of each line, as `\linepenalty` of TeX. A larger value gives fewer lines. The default is 10. */
+  readonly linePenalty?: number;
+  /** The cost of two hyphen breaks in sequence. The default is 3000, as `\doublehyphendemerits` of TeX. */
+  readonly flaggedCost?: number;
+}
+
+/**
+ * This function gives the total fit breaker of Knuth and Plass for text with a ragged right edge. It chooses the breaks with
+ * the least sum of demerits over all the lines. The demerits of a line are `(linePenalty + 100 r²)²` plus the square of the
+ * cost of its penalty. The ratio `r` is the free space of the line divided by the width. The last line has `r = 0`.
+ */
+export function totalFit(options: TotalFitOptions = {}): Breaker {
+  const linePenalty = options.linePenalty ?? 10;
+  const flaggedCost = options.flaggedCost ?? 3000;
+  return {
+    name: "total-fit",
+    breaks: (paragraph, width) => totalFitBreaks(paragraph, width, linePenalty, flaggedCost),
+  };
+}
+
+/** The total fit breaker with the default options. */
+export const knuthPlass: Breaker = totalFit();
+
+/** This function gives the breaks of the total fit breaker, by dynamic programming over the break opportunities. */
+function totalFitBreaks(paragraph: Paragraph, width: number, linePenalty: number, flaggedCost: number): number[] {
+  const { items } = paragraph;
+  // The nodes: the start of the paragraph (-1), each break opportunity, and the end (items.length)
+  const nodes = [-1];
+  for (let i = 0; i < items.length; i++) if (isBreak(items, i)) nodes.push(i);
+  nodes.push(items.length);
+  const best = new Array<number>(nodes.length).fill(Infinity);
+  const previous = new Array<number>(nodes.length).fill(-1);
+  best[0] = 0;
+  for (let a = 0; a < nodes.length - 1; a++) {
+    if (best[a] === Infinity) continue;
+    const start = a === 0 ? 0 : lineStart(items, nodes[a]!);
+    const flaggedBefore = a > 0 && isFlagged(paragraph, nodes[a]!);
+    for (let b = a + 1; b < nodes.length; b++) {
+      const end = nodes[b]!;
+      const last = b === nodes.length - 1;
+      const used = lineWidth(items, start, end);
+      const overflow = used > width;
+      // A line wider than the width is possible only when no break opportunity is inside it
+      if (overflow && b > a + 1) {
+        if (items[end]?.type === "penalty") continue;
+        break;
+      }
+      const penalty = items[end];
+      const cost = penalty?.type === "penalty" ? penalty.cost : 0;
+      const ratio = last || overflow ? 0 : (width - used) / width;
+      let demerits = (linePenalty + 100 * ratio * ratio) ** 2;
+      if (cost > 0) demerits += cost * cost;
+      else if (cost > -Infinity && cost < 0) demerits -= cost * cost;
+      if (flaggedBefore && isFlagged(paragraph, end)) demerits += flaggedCost;
+      const total = best[a]! + demerits;
+      if (total < best[b]!) {
+        best[b] = total;
+        previous[b] = a;
+      }
+      // A forced break ends each line that comes to it
+      if (cost === -Infinity) break;
+    }
+  }
+  const breaks: number[] = [];
+  for (let b = previous[nodes.length - 1]!; b > 0; b = previous[b]!) breaks.push(nodes[b]!);
+  return breaks.reverse();
+}
+
+/** This function tells if the item `index` is a flagged penalty. */
+function isFlagged(paragraph: Paragraph, index: number): boolean {
+  const item = paragraph.items[index];
+  return item?.type === "penalty" && item.flagged;
+}
+
+/** The options of the balanced breaker. */
+export interface BalancedOptions {
+  /** The steps of the search for the width. The default is 32. */
+  readonly steps?: number;
+}
+
+/**
+ * This function gives the balanced breaker, as a browser with `text-wrap: balance`. It keeps the line count of the greedy
+ * breaker, and it finds the least width that gives that count. Thus the lines have more equal widths.
+ */
+export function balancedBreaker(options: BalancedOptions = {}): Breaker {
+  const steps = options.steps ?? 32;
+  return {
+    name: "balanced",
+    breaks: (paragraph, width) => {
+      const count = greedyBreaks(paragraph, width).length;
+      let low = 0;
+      let high = width;
+      for (let step = 0; step < steps; step++) {
+        const middle = (low + high) / 2;
+        if (greedyBreaks(paragraph, middle).length === count) high = middle;
+        else low = middle;
+      }
+      return greedyBreaks(paragraph, high);
+    },
+  };
+}
+
+/** The balanced breaker with the default options. */
+export const balanced: Breaker = balancedBreaker();
+
+/** The breakers of the package, by name. */
+export const breakers: Readonly<Record<"greedy" | "total-fit" | "balanced", Breaker>> = { greedy, "total-fit": knuthPlass, balanced };

package/src/breaking/measures.ts

@@ -0,0 +1,27 @@
+import type { Line } from "./paragraph.ts";
+
+/**
+ * This function gives the raggedness of the lines for the width `width`: the mean of `((width - line) / width)²` over the
+ * lines before the last line. It is 0 for one line. `@mark1russell7/layout-contract/text` uses the same measure.
+ */
+export function raggedness(lines: readonly Line[], width: number): number {
+  if (lines.length < 2) return 0;
+  let sum = 0;
+  for (let i = 0; i < lines.length - 1; i++) {
+    const free = (width - lines[i]!.width) / width;
+    sum += free * free;
+  }
+  return sum / (lines.length - 1);
+}
+
+/** This function gives the spread of the lines: the width of the widest line less the width of the narrowest line, the last line included. */
+export function spread(lines: readonly Line[]): number {
+  if (lines.length === 0) return 0;
+  let widest = -Infinity;
+  let narrowest = Infinity;
+  for (const line of lines) {
+    widest = Math.max(widest, line.width);
+    narrowest = Math.min(narrowest, line.width);
+  }
+  return widest - narrowest;
+}

package/src/breaking/paragraph.ts

@@ -0,0 +1,145 @@
+/**
+ * The paragraph model of the breakers: a list of boxes, glue and penalties, as Knuth and Plass define it. A builder makes
+ * the items of a text. The breakers read only the items, so a new rule of break opportunities is a new builder.
+ */
+
+/** A width function: the width of a run of text, in any unit. The breakers add the widths and compare them. */
+export type WidthOf = (text: string) => number;
+
+/** A box: text that the breaker does not break. */
+export interface Box {
+  readonly type: "box";
+  readonly text: string;
+  readonly width: number;
+}
+
+/** Glue: a space between two boxes. A line can end at glue that comes after a box. The line then does not show the glue. */
+export interface Glue {
+  readonly type: "glue";
+  readonly text: string;
+  readonly width: number;
+}
+
+/**
+ * A penalty: a break opportunity with a cost. A line that ends at the penalty shows its text, for example a hyphen. A cost of
+ * `Infinity` forbids the break, and a cost of `-Infinity` forces it.
+ */
+export interface Penalty {
+  readonly type: "penalty";
+  readonly text: string;
+  readonly width: number;
+  readonly cost: number;
+  /** A flagged penalty is a hyphen. Total fit adds a cost to two flagged breaks in sequence. */
+  readonly flagged: boolean;
+}
+
+/** An item of a paragraph. */
+export type Item = Box | Glue | Penalty;
+
+/** A paragraph: the items in the order of the text. */
+export interface Paragraph {
+  readonly items: readonly Item[];
+}
+
+/** The options of `paragraphOf`. */
+export interface ParagraphOptions {
+  /** The width function of the boxes, the spaces and the hyphens. */
+  readonly widthOf: WidthOf;
+  /**
+   * The hyphenation hook. It gives the offsets in a word where a break with a hyphen is possible. The default gives no
+   * offset. The width of each part of a word comes from `widthOf`, so the kerning across an offset is not in the sum.
+   */
+  readonly hyphenate?: (word: string) => readonly number[];
+  /** The text that a line shows at a hyphen break. The default is "-". */
+  readonly hyphen?: string;
+  /** The cost of a hyphen break. The default is 50, as in TeX. */
+  readonly hyphenCost?: number;
+}
+
+const whiteSpace = /\s+/u;
+
+/**
+ * This function makes the paragraph of a text with the break opportunities of CSS `white-space: normal`. Each run of white
+ * space becomes one glue of the width of a space. Each word between two runs becomes a box, or boxes and hyphen penalties.
+ */
+export function paragraphOf(text: string, options: ParagraphOptions): Paragraph {
+  const { widthOf } = options;
+  const hyphen = options.hyphen ?? "-";
+  const hyphenCost = options.hyphenCost ?? 50;
+  const space = widthOf(" ");
+  const hyphenWidth = options.hyphenate === undefined ? 0 : widthOf(hyphen);
+  const items: Item[] = [];
+  for (const word of text.split(whiteSpace)) {
+    if (word === "") continue;
+    if (items.length > 0) items.push({ type: "glue", text: " ", width: space });
+    const offsets = options.hyphenate === undefined ? [] : [...new Set(options.hyphenate(word))].filter((o) => o > 0 && o < word.length).sort((a, b) => a - b);
+    let start = 0;
+    for (const offset of offsets) {
+      const part = word.slice(start, offset);
+      items.push({ type: "box", text: part, width: widthOf(part) });
+      items.push({ type: "penalty", text: hyphen, width: hyphenWidth, cost: hyphenCost, flagged: true });
+      start = offset;
+    }
+    const last = word.slice(start);
+    items.push({ type: "box", text: last, width: widthOf(last) });
+  }
+  return { items };
+}
+
+/** A line of a broken paragraph. */
+export interface Line {
+  readonly text: string;
+  /** The width of the line: its boxes, the glue between them and the text of a penalty at its end. */
+  readonly width: number;
+  /** The index of the first item of the line. */
+  readonly start: number;
+  /** The index after the last item of the line. A break at glue or at a penalty has the index of that item. */
+  readonly end: number;
+}
+
+/** This function tells if a line can end at the item `index`: glue after a box, or a penalty with a cost below `Infinity`. */
+export function isBreak(items: readonly Item[], index: number): boolean {
+  const item = items[index]!;
+  if (item.type === "glue") return index > 0 && items[index - 1]!.type === "box";
+  return item.type === "penalty" && item.cost < Infinity;
+}
+
+/** This function gives the index of the first item of a line after a break at `index`. It skips the glue and the penalties. */
+export function lineStart(items: readonly Item[], index: number): number {
+  let i = index + 1;
+  while (i < items.length && items[i]!.type !== "box") i++;
+  return i;
+}
+
+/** This function gives the width of the line from the item `start` to a break at `end`, with the text of a penalty at `end`. */
+export function lineWidth(items: readonly Item[], start: number, end: number): number {
+  let width = 0;
+  for (let i = start; i < end; i++) {
+    const item = items[i]!;
+    if (item.type !== "penalty") width += item.width;
+  }
+  const last = items[end];
+  return last?.type === "penalty" ? width + last.width : width;
+}
+
+/**
+ * This function gives the lines of a paragraph from the indices of its breaks. Each break is the index of glue or of a penalty.
+ * The last line ends at the end of the items.
+ */
+export function linesOf(paragraph: Paragraph, breaks: readonly number[]): Line[] {
+  const { items } = paragraph;
+  const lines: Line[] = [];
+  let start = 0;
+  for (const end of [...breaks, items.length]) {
+    let text = "";
+    for (let i = start; i < end; i++) {
+      const item = items[i]!;
+      if (item.type !== "penalty") text += item.text;
+    }
+    const last = items[end];
+    if (last?.type === "penalty") text += last.text;
+    lines.push({ text, width: lineWidth(items, start, end), start, end });
+    start = lineStart(items, end);
+  }
+  return lines;
+}

package/src/breaking.ts

@@ -0,0 +1,3 @@
+export { balanced, balancedBreaker, breakers, greedy, knuthPlass, totalFit, type BalancedOptions, type Breaker, type TotalFitOptions } from "./breaking/breakers.ts";
+export { raggedness, spread } from "./breaking/measures.ts";
+export { isBreak, lineStart, lineWidth, linesOf, paragraphOf, type Box, type Glue, type Item, type Line, type Paragraph, type ParagraphOptions, type Penalty, type WidthOf } from "./breaking/paragraph.ts";

package/src/index.ts

@@ -0,0 +1,5 @@
+/**
+ * The entry of `@mark1russell7/typeset`. Each area of the package has its own subpath, for example
+ * `@mark1russell7/typeset/breaking`. This entry gives each area as one namespace.
+ */
+export * as breaking from "./breaking.ts";