@mark1russell7/typeset 0.1.0 → 0.1.1

package/README.md

@@ -5,6 +5,7 @@ This package measures text and breaks it into lines. Each area has its own subpa
 | Subpath | What it has |
 | --- | --- |
 | `@mark1russell7/typeset/breaking` | The paragraph model of boxes, glue and penalties, and the greedy, total fit and balanced line breakers. |
+| `@mark1russell7/typeset/text` | The `Text` rope: a text with its width, and edits that measure only the changed parts. |
 
 ## Line breaking
 
@@ -20,4 +21,21 @@ const lines = linesOf(paragraph, knuthPlass.breaks(paragraph, 120));
 - `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 Text rope
+
+```ts
+import { Text } from "@mark1russell7/typeset/text";
+
+const widthOf = (text: string): number => 8 * [...text].length;
+const text = Text.from("The quick brown fox", widthOf);
+const edited = text.insert(4, "very ").remove(0, 4);
+console.log(edited.toString(), edited.width);
+```
+
+- Each edit gives a new rope. The old rope does not change, and the two share the parts that the edit does not touch.
+- An edit uses the width function of the order of `log n` times, on the changed leaves and on short windows.
+- The width is exact when the width function obeys the separator law: `width(p + s + q) = width(p + s) + width(s + q) - width(s)`.
+- The separator `s` is a space or a tab. The option `separators` changes the set.
+- The width model of the repository obeys the law for its shaping `dom` and `canvas`, with the sum `exact`.
+
 The repository [mark1russell7/typeset](https://github.com/mark1russell7/typeset) has the report of the breakers in `docs/BREAKING.md`.

package/build/breaking.d.ts

@@ -1,2 +1,3 @@
-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";
+import { a as Paragraph, c as WidthOf, d as lineWidth, f as linesOf, i as Line, l as isBreak, n as Glue, o as ParagraphOptions, p as paragraphOf, r as Item, s as Penalty, t as Box, u as lineStart } from "./chunks/paragraph.js";
+import { a as Breaker, c as balancedBreaker, d as knuthPlass, f as totalFit, i as BalancedOptions, l as breakers, n as raggedness, o as TotalFitOptions, r as spread, s as balanced, u as greedy } 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/chunks/breaking.d.ts

@@ -1,79 +1,4 @@
-/**
- * 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[];
+import { a as Paragraph, c as WidthOf, d as lineWidth, f as linesOf, i as Line, l as isBreak, n as Glue, o as ParagraphOptions, p as paragraphOf, r as Item, s as Penalty, t as Box, u as lineStart } from "./paragraph.js";
 /**
  * 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.
@@ -126,5 +51,5 @@ 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 };
+export { Breaker as a, balancedBreaker as c, knuthPlass as d, totalFit as f, BalancedOptions as i, breakers as l, raggedness as n, TotalFitOptions as o, spread as r, balanced as s, breaking_d_exports as t, greedy as u };
 //# sourceMappingURL=breaking.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"breaking.d.ts","names":[],"sources":["../../src/breaking/breakers.ts","../../src/breaking/measures.ts","../../src/breaking.ts"],"mappings":";;;;;UAMiB;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/paragraph.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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[];
+export { Paragraph as a, WidthOf as c, lineWidth as d, linesOf as f, Line as i, isBreak as l, Glue as n, ParagraphOptions as o, paragraphOf as p, Item as r, Penalty as s, Box as t, lineStart as u };
+//# sourceMappingURL=paragraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","names":[],"sources":["../../src/breaking/paragraph.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"}

package/build/chunks/text.d.ts

@@ -0,0 +1,48 @@
+import { c as WidthOf } from "./paragraph.js";
+/** The options of a rope. */
+interface TextOptions {
+  /**
+   * The separators of the separator law: each character is one UTF-16 code unit. The default is a space and a tab. An
+   * empty string makes each seam measure the full text of the two sides.
+   */
+  readonly separators?: string;
+  /** The largest count of UTF-16 code units in a leaf. The default is 256. */
+  readonly chunk?: number;
+}
+/**
+ * A text with its width: a persistent balanced rope. Each edit gives a new `Text` and does not change this one. The offsets
+ * are in UTF-16 code units, as the offsets of a JavaScript string.
+ */
+declare class Text {
+  #private;
+  private constructor();
+  /** This function makes the rope of `text` with the width function `width`. */
+  static from(text: string, width: WidthOf, options?: TextOptions): Text;
+  /** The count of UTF-16 code units of the text. */
+  get length(): number;
+  /** The width of the text. It is equal to the width of the flat string when the width function obeys the separator law. */
+  get width(): number;
+  /** The height of the tree: 0 for a text of one leaf. The tests use it to examine the balance. */
+  get height(): number;
+  /** This function gives the flat string. */
+  toString(): string;
+  /** This function gives the strings of the leaves in the order of the text. */
+  chunks(): string[];
+  /** This function gives the text from `start` to `end`, as a new rope. */
+  slice(start: number, end?: number): Text;
+  /** This function gives the width of the text from `start` to `end`. */
+  widthOf(start: number, end?: number): number;
+  /** This function gives this text and then `other`. The two ropes must have the same width function and options. */
+  concat(other: Text): Text;
+  /** This function puts `text` at the offset `at`. */
+  insert(at: number, text: string): Text;
+  /** This function removes the text from `start` to `end`. */
+  remove(start: number, end: number): Text;
+  /** This function puts `text` in place of the text from `start` to `end`. */
+  replace(start: number, end: number, text: string): Text;
+}
+declare namespace text_d_exports {
+  export { Text, TextOptions };
+}
+export { Text as n, TextOptions as r, text_d_exports as t };
+//# sourceMappingURL=text.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","names":[],"sources":["../../src/text/rope.ts","../../src/text.ts"],"mappings":";;UAYiB;;;;;WAKN;;WAEA;;;;;;cAkLE;;UAIH;;SAMD,KAAK,cAAc,OAAO,SAAS,UAAS,cAAmB;;MAalE;;MAKA;;MAKA;;EAKJ;;EAKA;;EAKA,MAAM,eAAe,eAA4B;;EAQjD,QAAQ,eAAe;;EAKvB,OAAO,OAAO,OAAO;;EASrB,OAAO,YAAY,eAAe;;EAKlC,OAAO,eAAe,cAAc;;EAKpC,QAAQ,eAAe,aAAa,eAAe"}

package/build/chunks/text.js

@@ -0,0 +1,237 @@
+import { t as __exportAll } from "./rolldown-runtime.js";
+// src/text/rope.ts
+function isSeparator(context, code) {
+	for (let i = 0; i < context.separators.length; i++) if (context.separators.charCodeAt(i) === code) return true;
+	return false;
+}
+function leafOf(context, text) {
+	const width = context.width(text);
+	let first = -1;
+	let last = -1;
+	for (let i = 0; i < text.length; i++) {
+		if (!isSeparator(context, text.charCodeAt(i))) continue;
+		if (first < 0) first = i;
+		last = i;
+	}
+	if (first < 0) return {
+		kind: "leaf",
+		text,
+		height: 0,
+		length: text.length,
+		width,
+		separated: false,
+		head: text,
+		headWidth: width,
+		tail: text,
+		tailWidth: width
+	};
+	const head = text.slice(0, first + 1);
+	const tail = text.slice(last);
+	return {
+		kind: "leaf",
+		text,
+		height: 0,
+		length: text.length,
+		width,
+		separated: true,
+		head,
+		headWidth: context.width(head),
+		tail,
+		tailWidth: context.width(tail)
+	};
+}
+/**
+* This function makes the branch of two subtrees. It measures one window: the tail of the left side and the head of the right
+* side. The separator law then gives the width of all the text from the widths of the two sides.
+*/
+function branchOf(context, left, right) {
+	const seam = left.tail + right.head;
+	const seamWidth = context.width(seam);
+	let width;
+	if (!left.separated && !right.separated) width = seamWidth;
+	else if (!left.separated) width = right.width - right.headWidth + seamWidth;
+	else if (!right.separated) width = left.width - left.tailWidth + seamWidth;
+	else width = left.width + right.width - left.tailWidth - right.headWidth + seamWidth;
+	return {
+		kind: "branch",
+		left,
+		right,
+		height: Math.max(left.height, right.height) + 1,
+		length: left.length + right.length,
+		width,
+		separated: left.separated || right.separated,
+		head: left.separated ? left.head : seam,
+		headWidth: left.separated ? left.headWidth : seamWidth,
+		tail: right.separated ? right.tail : seam,
+		tailWidth: right.separated ? right.tailWidth : seamWidth
+	};
+}
+/** This function joins two trees in the order of the text and keeps the heights of the two children within 1. */
+function join(context, left, right) {
+	if (left === void 0) return right;
+	if (right === void 0) return left;
+	if (left.kind === "leaf" && right.kind === "leaf" && left.length + right.length <= context.chunk) return leafOf(context, left.text + right.text);
+	if (left.height > right.height + 1) {
+		const branch = left;
+		const joined = join(context, branch.right, right);
+		if (joined.height <= branch.left.height + 1) return branchOf(context, branch.left, joined);
+		return rotateLeft(context, branch.left, joined);
+	}
+	if (right.height > left.height + 1) {
+		const branch = right;
+		const joined = join(context, left, branch.left);
+		if (joined.height <= branch.right.height + 1) return branchOf(context, joined, branch.right);
+		return rotateRight(context, joined, branch.right);
+	}
+	return branchOf(context, left, right);
+}
+/** This function balances the branch of `left` and `heavy`, when `heavy` is 2 levels higher than `left`. */
+function rotateLeft(context, left, heavy) {
+	if (heavy.left.height <= heavy.right.height) return branchOf(context, branchOf(context, left, heavy.left), heavy.right);
+	const middle = heavy.left;
+	return branchOf(context, branchOf(context, left, middle.left), branchOf(context, middle.right, heavy.right));
+}
+/** This function balances the branch of `heavy` and `right`, when `heavy` is 2 levels higher than `right`. */
+function rotateRight(context, heavy, right) {
+	if (heavy.right.height <= heavy.left.height) return branchOf(context, heavy.left, branchOf(context, heavy.right, right));
+	const middle = heavy.right;
+	return branchOf(context, branchOf(context, heavy.left, middle.left), branchOf(context, middle.right, right));
+}
+/** This function divides a tree at the UTF-16 offset `at` into the text before and the text after. */
+function split(context, node, at) {
+	if (node === void 0) return [void 0, void 0];
+	if (at <= 0) return [void 0, node];
+	if (at >= node.length) return [node, void 0];
+	if (node.kind === "leaf") return [leafOf(context, node.text.slice(0, at)), leafOf(context, node.text.slice(at))];
+	if (at === node.left.length) return [node.left, node.right];
+	if (at < node.left.length) {
+		const [before, after] = split(context, node.left, at);
+		return [before, join(context, after, node.right)];
+	}
+	const [before, after] = split(context, node.right, at - node.left.length);
+	return [join(context, node.left, before), after];
+}
+/** This function gives the end of the next leaf of `text` from `start`: after a separator when it can, and not in a surrogate pair. */
+function chunkEnd(context, text, start) {
+	const limit = start + context.chunk;
+	if (limit >= text.length) return text.length;
+	for (let i = limit - 1; i >= start + context.chunk / 2; i--) if (isSeparator(context, text.charCodeAt(i))) return i + 1;
+	const code = text.charCodeAt(limit - 1);
+	return code >= 55296 && code <= 56319 ? limit - 1 : limit;
+}
+/** This function makes a balanced tree of a text: leaves of at most `chunk` code units, and then a level of branches at a time. */
+function build(context, text) {
+	let level = [];
+	for (let start = 0; start < text.length;) {
+		const end = chunkEnd(context, text, start);
+		level.push(leafOf(context, text.slice(start, end)));
+		start = end;
+	}
+	if (level.length === 0) return void 0;
+	while (level.length > 1) {
+		const next = [];
+		for (let i = 0; i + 1 < level.length; i += 2) next.push(branchOf(context, level[i], level[i + 1]));
+		if (level.length % 2 === 1) next.push(level[level.length - 1]);
+		level = next;
+	}
+	return level[0];
+}
+function leaves(node, out) {
+	if (node === void 0) return out;
+	const stack = [node];
+	while (stack.length > 0) {
+		const top = stack.pop();
+		if (top.kind === "leaf") out.push(top.text);
+		else stack.push(top.right, top.left);
+	}
+	return out;
+}
+/**
+* A text with its width: a persistent balanced rope. Each edit gives a new `Text` and does not change this one. The offsets
+* are in UTF-16 code units, as the offsets of a JavaScript string.
+*/
+var Text = class Text {
+	#context;
+	#root;
+	constructor(context, root) {
+		this.#context = context;
+		this.#root = root;
+	}
+	/** This function makes the rope of `text` with the width function `width`. */
+	static from(text, width, options = {}) {
+		const separators = options.separators ?? " 	";
+		const chunk = options.chunk ?? 256;
+		if (!Number.isInteger(chunk) || chunk < 2) throw new RangeError(`the chunk is ${chunk}, not an integer of 2 or more`);
+		for (let i = 0; i < separators.length; i++) {
+			const code = separators.charCodeAt(i);
+			if (code >= 55296 && code <= 57343) throw new RangeError("a separator is one UTF-16 code unit, not a half of a surrogate pair");
+		}
+		const context = {
+			width,
+			separators,
+			chunk
+		};
+		return new Text(context, build(context, text));
+	}
+	/** The count of UTF-16 code units of the text. */
+	get length() {
+		return this.#root?.length ?? 0;
+	}
+	/** The width of the text. It is equal to the width of the flat string when the width function obeys the separator law. */
+	get width() {
+		return this.#root?.width ?? 0;
+	}
+	/** The height of the tree: 0 for a text of one leaf. The tests use it to examine the balance. */
+	get height() {
+		return this.#root?.height ?? 0;
+	}
+	/** This function gives the flat string. */
+	toString() {
+		return leaves(this.#root, []).join("");
+	}
+	/** This function gives the strings of the leaves in the order of the text. */
+	chunks() {
+		return leaves(this.#root, []);
+	}
+	/** This function gives the text from `start` to `end`, as a new rope. */
+	slice(start, end = this.length) {
+		this.#check(start, end);
+		const [, after] = split(this.#context, this.#root, start);
+		const [middle] = split(this.#context, after, end - start);
+		return new Text(this.#context, middle);
+	}
+	/** This function gives the width of the text from `start` to `end`. */
+	widthOf(start, end = this.length) {
+		return this.slice(start, end).width;
+	}
+	/** This function gives this text and then `other`. The two ropes must have the same width function and options. */
+	concat(other) {
+		const context = other.#context;
+		if (context.width !== this.#context.width || context.separators !== this.#context.separators || context.chunk !== this.#context.chunk) throw new TypeError("the two ropes have different width functions or options");
+		return new Text(this.#context, join(this.#context, this.#root, other.#root));
+	}
+	/** This function puts `text` at the offset `at`. */
+	insert(at, text) {
+		return this.replace(at, at, text);
+	}
+	/** This function removes the text from `start` to `end`. */
+	remove(start, end) {
+		return this.replace(start, end, "");
+	}
+	/** This function puts `text` in place of the text from `start` to `end`. */
+	replace(start, end, text) {
+		this.#check(start, end);
+		const [before, rest] = split(this.#context, this.#root, start);
+		const [, after] = split(this.#context, rest, end - start);
+		const middle = build(this.#context, text);
+		return new Text(this.#context, join(this.#context, join(this.#context, before, middle), after));
+	}
+	#check(start, end) {
+		if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > this.length) throw new RangeError(`the range ${start} to ${end} is not in the text of length ${this.length}`);
+	}
+};
+// src/text.ts
+var text_exports = /* @__PURE__ */ __exportAll({ Text: () => Text });
+export { Text as n, text_exports as t };
+
+//# sourceMappingURL=text.js.map

package/build/chunks/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","names":[],"sources":["../../src/text/rope.ts","../../src/text.ts"],"sourcesContent":["/**\n * The `Text` rope: a persistent balanced tree of strings with the width and the length of each subtree. An edit makes a\n * new rope. The new rope shares the subtrees that do not change. A width function gives the width of a run of text. The\n * rope uses it only for the leaves and for the windows at the seams. Thus an edit uses it of the order of `log n` times.\n *\n * The seams are exact when the width function obeys the separator law. For each text `p + s + q` with a separator `s`:\n * `width(p + s + q) = width(p + s) + width(s + q) - width(s)`. The model of `@typeset/fonts` obeys it for a space and a\n * tab. It shapes each word alone, and its kerning goes only between two adjacent glyphs.\n */\nimport type { WidthOf } from \"../breaking/paragraph.ts\";\n\n/** The options of a rope. */\nexport interface TextOptions {\n  /**\n   * The separators of the separator law: each character is one UTF-16 code unit. The default is a space and a tab. An\n   * empty string makes each seam measure the full text of the two sides.\n   */\n  readonly separators?: string;\n  /** The largest count of UTF-16 code units in a leaf. The default is 256. */\n  readonly chunk?: number;\n}\n\n/** The summary of a subtree: its length, its width, and the two ends that a seam measures again. */\ninterface Summary {\n  /** The count of UTF-16 code units. */\n  readonly length: number;\n  readonly width: number;\n  /** This value is `true` when the text has a separator. */\n  readonly separated: boolean;\n  /** The text through the first separator, or all the text when the text has no separator. */\n  readonly head: string;\n  readonly headWidth: number;\n  /** The text from the last separator, or all the text when the text has no separator. */\n  readonly tail: string;\n  readonly tailWidth: number;\n}\n\ninterface Leaf extends Summary {\n  readonly kind: \"leaf\";\n  readonly text: string;\n  readonly height: 0;\n}\n\ninterface Branch extends Summary {\n  readonly kind: \"branch\";\n  readonly left: Node;\n  readonly right: Node;\n  readonly height: number;\n}\n\ntype Node = Leaf | Branch;\n\n/** The shared state of the ropes of one width function and one set of options. */\ninterface Context {\n  readonly width: WidthOf;\n  readonly separators: string;\n  readonly chunk: number;\n}\n\nfunction isSeparator(context: Context, code: number): boolean {\n  for (let i = 0; i < context.separators.length; i++) if (context.separators.charCodeAt(i) === code) return true;\n  return false;\n}\n\nfunction leafOf(context: Context, text: string): Leaf {\n  const width = context.width(text);\n  let first = -1;\n  let last = -1;\n  for (let i = 0; i < text.length; i++) {\n    if (!isSeparator(context, text.charCodeAt(i))) continue;\n    if (first < 0) first = i;\n    last = i;\n  }\n  if (first < 0) return { kind: \"leaf\", text, height: 0, length: text.length, width, separated: false, head: text, headWidth: width, tail: text, tailWidth: width };\n  const head = text.slice(0, first + 1);\n  const tail = text.slice(last);\n  return { kind: \"leaf\", text, height: 0, length: text.length, width, separated: true, head, headWidth: context.width(head), tail, tailWidth: context.width(tail) };\n}\n\n/**\n * This function makes the branch of two subtrees. It measures one window: the tail of the left side and the head of the right\n * side. The separator law then gives the width of all the text from the widths of the two sides.\n */\nfunction branchOf(context: Context, left: Node, right: Node): Branch {\n  const seam = left.tail + right.head;\n  const seamWidth = context.width(seam);\n  let width: number;\n  if (!left.separated && !right.separated) width = seamWidth;\n  else if (!left.separated) width = right.width - right.headWidth + seamWidth;\n  else if (!right.separated) width = left.width - left.tailWidth + seamWidth;\n  else width = left.width + right.width - left.tailWidth - right.headWidth + seamWidth;\n  return {\n    kind: \"branch\",\n    left,\n    right,\n    height: Math.max(left.height, right.height) + 1,\n    length: left.length + right.length,\n    width,\n    separated: left.separated || right.separated,\n    head: left.separated ? left.head : seam,\n    headWidth: left.separated ? left.headWidth : seamWidth,\n    tail: right.separated ? right.tail : seam,\n    tailWidth: right.separated ? right.tailWidth : seamWidth,\n  };\n}\n\n/** This function joins two trees in the order of the text and keeps the heights of the two children within 1. */\nfunction join(context: Context, left: Node | undefined, right: Node | undefined): Node | undefined {\n  if (left === undefined) return right;\n  if (right === undefined) return left;\n  if (left.kind === \"leaf\" && right.kind === \"leaf\" && left.length + right.length <= context.chunk) return leafOf(context, left.text + right.text);\n  if (left.height > right.height + 1) {\n    const branch = left as Branch;\n    const joined = join(context, branch.right, right)!;\n    if (joined.height <= branch.left.height + 1) return branchOf(context, branch.left, joined);\n    return rotateLeft(context, branch.left, joined as Branch);\n  }\n  if (right.height > left.height + 1) {\n    const branch = right as Branch;\n    const joined = join(context, left, branch.left)!;\n    if (joined.height <= branch.right.height + 1) return branchOf(context, joined, branch.right);\n    return rotateRight(context, joined as Branch, branch.right);\n  }\n  return branchOf(context, left, right);\n}\n\n/** This function balances the branch of `left` and `heavy`, when `heavy` is 2 levels higher than `left`. */\nfunction rotateLeft(context: Context, left: Node, heavy: Branch): Branch {\n  if (heavy.left.height <= heavy.right.height) return branchOf(context, branchOf(context, left, heavy.left), heavy.right);\n  const middle = heavy.left as Branch;\n  return branchOf(context, branchOf(context, left, middle.left), branchOf(context, middle.right, heavy.right));\n}\n\n/** This function balances the branch of `heavy` and `right`, when `heavy` is 2 levels higher than `right`. */\nfunction rotateRight(context: Context, heavy: Branch, right: Node): Branch {\n  if (heavy.right.height <= heavy.left.height) return branchOf(context, heavy.left, branchOf(context, heavy.right, right));\n  const middle = heavy.right as Branch;\n  return branchOf(context, branchOf(context, heavy.left, middle.left), branchOf(context, middle.right, right));\n}\n\n/** This function divides a tree at the UTF-16 offset `at` into the text before and the text after. */\nfunction split(context: Context, node: Node | undefined, at: number): [Node | undefined, Node | undefined] {\n  if (node === undefined) return [undefined, undefined];\n  if (at <= 0) return [undefined, node];\n  if (at >= node.length) return [node, undefined];\n  if (node.kind === \"leaf\") return [leafOf(context, node.text.slice(0, at)), leafOf(context, node.text.slice(at))];\n  if (at === node.left.length) return [node.left, node.right];\n  if (at < node.left.length) {\n    const [before, after] = split(context, node.left, at);\n    return [before, join(context, after, node.right)];\n  }\n  const [before, after] = split(context, node.right, at - node.left.length);\n  return [join(context, node.left, before), after];\n}\n\n/** This function gives the end of the next leaf of `text` from `start`: after a separator when it can, and not in a surrogate pair. */\nfunction chunkEnd(context: Context, text: string, start: number): number {\n  const limit = start + context.chunk;\n  if (limit >= text.length) return text.length;\n  for (let i = limit - 1; i >= start + context.chunk / 2; i--) if (isSeparator(context, text.charCodeAt(i))) return i + 1;\n  const code = text.charCodeAt(limit - 1);\n  return code >= 0xd800 && code <= 0xdbff ? limit - 1 : limit;\n}\n\n/** This function makes a balanced tree of a text: leaves of at most `chunk` code units, and then a level of branches at a time. */\nfunction build(context: Context, text: string): Node | undefined {\n  let level: Node[] = [];\n  for (let start = 0; start < text.length; ) {\n    const end = chunkEnd(context, text, start);\n    level.push(leafOf(context, text.slice(start, end)));\n    start = end;\n  }\n  if (level.length === 0) return undefined;\n  while (level.length > 1) {\n    const next: Node[] = [];\n    for (let i = 0; i + 1 < level.length; i += 2) next.push(branchOf(context, level[i]!, level[i + 1]!));\n    if (level.length % 2 === 1) next.push(level[level.length - 1]!);\n    level = next;\n  }\n  return level[0];\n}\n\nfunction leaves(node: Node | undefined, out: string[]): string[] {\n  if (node === undefined) return out;\n  const stack: Node[] = [node];\n  while (stack.length > 0) {\n    const top = stack.pop()!;\n    if (top.kind === \"leaf\") out.push(top.text);\n    else stack.push(top.right, top.left);\n  }\n  return out;\n}\n\n/**\n * A text with its width: a persistent balanced rope. Each edit gives a new `Text` and does not change this one. The offsets\n * are in UTF-16 code units, as the offsets of a JavaScript string.\n */\nexport class Text {\n  readonly #context: Context;\n  readonly #root: Node | undefined;\n\n  private constructor(context: Context, root: Node | undefined) {\n    this.#context = context;\n    this.#root = root;\n  }\n\n  /** This function makes the rope of `text` with the width function `width`. */\n  static from(text: string, width: WidthOf, options: TextOptions = {}): Text {\n    const separators = options.separators ?? \" \\t\";\n    const chunk = options.chunk ?? 256;\n    if (!Number.isInteger(chunk) || chunk < 2) throw new RangeError(`the chunk is ${chunk}, not an integer of 2 or more`);\n    for (let i = 0; i < separators.length; i++) {\n      const code = separators.charCodeAt(i);\n      if (code >= 0xd800 && code <= 0xdfff) throw new RangeError(\"a separator is one UTF-16 code unit, not a half of a surrogate pair\");\n    }\n    const context: Context = { width, separators, chunk };\n    return new Text(context, build(context, text));\n  }\n\n  /** The count of UTF-16 code units of the text. */\n  get length(): number {\n    return this.#root?.length ?? 0;\n  }\n\n  /** The width of the text. It is equal to the width of the flat string when the width function obeys the separator law. */\n  get width(): number {\n    return this.#root?.width ?? 0;\n  }\n\n  /** The height of the tree: 0 for a text of one leaf. The tests use it to examine the balance. */\n  get height(): number {\n    return this.#root?.height ?? 0;\n  }\n\n  /** This function gives the flat string. */\n  toString(): string {\n    return leaves(this.#root, []).join(\"\");\n  }\n\n  /** This function gives the strings of the leaves in the order of the text. */\n  chunks(): string[] {\n    return leaves(this.#root, []);\n  }\n\n  /** This function gives the text from `start` to `end`, as a new rope. */\n  slice(start: number, end: number = this.length): Text {\n    this.#check(start, end);\n    const [, after] = split(this.#context, this.#root, start);\n    const [middle] = split(this.#context, after, end - start);\n    return new Text(this.#context, middle);\n  }\n\n  /** This function gives the width of the text from `start` to `end`. */\n  widthOf(start: number, end: number = this.length): number {\n    return this.slice(start, end).width;\n  }\n\n  /** This function gives this text and then `other`. The two ropes must have the same width function and options. */\n  concat(other: Text): Text {\n    const context = other.#context;\n    if (context.width !== this.#context.width || context.separators !== this.#context.separators || context.chunk !== this.#context.chunk) {\n      throw new TypeError(\"the two ropes have different width functions or options\");\n    }\n    return new Text(this.#context, join(this.#context, this.#root, other.#root));\n  }\n\n  /** This function puts `text` at the offset `at`. */\n  insert(at: number, text: string): Text {\n    return this.replace(at, at, text);\n  }\n\n  /** This function removes the text from `start` to `end`. */\n  remove(start: number, end: number): Text {\n    return this.replace(start, end, \"\");\n  }\n\n  /** This function puts `text` in place of the text from `start` to `end`. */\n  replace(start: number, end: number, text: string): Text {\n    this.#check(start, end);\n    const [before, rest] = split(this.#context, this.#root, start);\n    const [, after] = split(this.#context, rest, end - start);\n    const middle = build(this.#context, text);\n    return new Text(this.#context, join(this.#context, join(this.#context, before, middle), after));\n  }\n\n  #check(start: number, end: number): void {\n    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > this.length) {\n      throw new RangeError(`the range ${start} to ${end} is not in the text of length ${this.length}`);\n    }\n  }\n}\n","export { Text, type TextOptions } from \"./text/rope.ts\";\n"],"mappings":";;AA2DA,SAAS,YAAY,SAAkB,MAAuB;CAC5D,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,WAAW,QAAQ,KAAK,IAAI,QAAQ,WAAW,WAAW,CAAC,MAAM,MAAM,OAAO;CAC1G,OAAO;AACT;AAEA,SAAS,OAAO,SAAkB,MAAoB;CACpD,MAAM,QAAQ,QAAQ,MAAM,IAAI;CAChC,IAAI,QAAQ;CACZ,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,IAAI,CAAC,YAAY,SAAS,KAAK,WAAW,CAAC,CAAC,GAAG;EAC/C,IAAI,QAAQ,GAAG,QAAQ;EACvB,OAAO;CACT;CACA,IAAI,QAAQ,GAAG,OAAO;EAAE,MAAM;EAAQ;EAAM,QAAQ;EAAG,QAAQ,KAAK;EAAQ;EAAO,WAAW;EAAO,MAAM;EAAM,WAAW;EAAO,MAAM;EAAM,WAAW;CAAM;CAChK,MAAM,OAAO,KAAK,MAAM,GAAG,QAAQ,CAAC;CACpC,MAAM,OAAO,KAAK,MAAM,IAAI;CAC5B,OAAO;EAAE,MAAM;EAAQ;EAAM,QAAQ;EAAG,QAAQ,KAAK;EAAQ;EAAO,WAAW;EAAM;EAAM,WAAW,QAAQ,MAAM,IAAI;EAAG;EAAM,WAAW,QAAQ,MAAM,IAAI;CAAE;AAClK;;;;;AAMA,SAAS,SAAS,SAAkB,MAAY,OAAqB;CACnE,MAAM,OAAO,KAAK,OAAO,MAAM;CAC/B,MAAM,YAAY,QAAQ,MAAM,IAAI;CACpC,IAAI;CACJ,IAAI,CAAC,KAAK,aAAa,CAAC,MAAM,WAAW,QAAQ;MAC5C,IAAI,CAAC,KAAK,WAAW,QAAQ,MAAM,QAAQ,MAAM,YAAY;MAC7D,IAAI,CAAC,MAAM,WAAW,QAAQ,KAAK,QAAQ,KAAK,YAAY;MAC5D,QAAQ,KAAK,QAAQ,MAAM,QAAQ,KAAK,YAAY,MAAM,YAAY;CAC3E,OAAO;EACL,MAAM;EACN;EACA;EACA,QAAQ,KAAK,IAAI,KAAK,QAAQ,MAAM,MAAM,IAAI;EAC9C,QAAQ,KAAK,SAAS,MAAM;EAC5B;EACA,WAAW,KAAK,aAAa,MAAM;EACnC,MAAM,KAAK,YAAY,KAAK,OAAO;EACnC,WAAW,KAAK,YAAY,KAAK,YAAY;EAC7C,MAAM,MAAM,YAAY,MAAM,OAAO;EACrC,WAAW,MAAM,YAAY,MAAM,YAAY;CACjD;AACF;;AAGA,SAAS,KAAK,SAAkB,MAAwB,OAA2C;CACjG,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,KAAK,SAAS,UAAU,MAAM,SAAS,UAAU,KAAK,SAAS,MAAM,UAAU,QAAQ,OAAO,OAAO,OAAO,SAAS,KAAK,OAAO,MAAM,IAAI;CAC/I,IAAI,KAAK,SAAS,MAAM,SAAS,GAAG;EAClC,MAAM,SAAS;EACf,MAAM,SAAS,KAAK,SAAS,OAAO,OAAO,KAAK;EAChD,IAAI,OAAO,UAAU,OAAO,KAAK,SAAS,GAAG,OAAO,SAAS,SAAS,OAAO,MAAM,MAAM;EACzF,OAAO,WAAW,SAAS,OAAO,MAAM,MAAgB;CAC1D;CACA,IAAI,MAAM,SAAS,KAAK,SAAS,GAAG;EAClC,MAAM,SAAS;EACf,MAAM,SAAS,KAAK,SAAS,MAAM,OAAO,IAAI;EAC9C,IAAI,OAAO,UAAU,OAAO,MAAM,SAAS,GAAG,OAAO,SAAS,SAAS,QAAQ,OAAO,KAAK;EAC3F,OAAO,YAAY,SAAS,QAAkB,OAAO,KAAK;CAC5D;CACA,OAAO,SAAS,SAAS,MAAM,KAAK;AACtC;;AAGA,SAAS,WAAW,SAAkB,MAAY,OAAuB;CACvE,IAAI,MAAM,KAAK,UAAU,MAAM,MAAM,QAAQ,OAAO,SAAS,SAAS,SAAS,SAAS,MAAM,MAAM,IAAI,GAAG,MAAM,KAAK;CACtH,MAAM,SAAS,MAAM;CACrB,OAAO,SAAS,SAAS,SAAS,SAAS,MAAM,OAAO,IAAI,GAAG,SAAS,SAAS,OAAO,OAAO,MAAM,KAAK,CAAC;AAC7G;;AAGA,SAAS,YAAY,SAAkB,OAAe,OAAqB;CACzE,IAAI,MAAM,MAAM,UAAU,MAAM,KAAK,QAAQ,OAAO,SAAS,SAAS,MAAM,MAAM,SAAS,SAAS,MAAM,OAAO,KAAK,CAAC;CACvH,MAAM,SAAS,MAAM;CACrB,OAAO,SAAS,SAAS,SAAS,SAAS,MAAM,MAAM,OAAO,IAAI,GAAG,SAAS,SAAS,OAAO,OAAO,KAAK,CAAC;AAC7G;;AAGA,SAAS,MAAM,SAAkB,MAAwB,IAAkD;CACzG,IAAI,SAAS,KAAA,GAAW,OAAO,CAAC,KAAA,GAAW,KAAA,CAAS;CACpD,IAAI,MAAM,GAAG,OAAO,CAAC,KAAA,GAAW,IAAI;CACpC,IAAI,MAAM,KAAK,QAAQ,OAAO,CAAC,MAAM,KAAA,CAAS;CAC9C,IAAI,KAAK,SAAS,QAAQ,OAAO,CAAC,OAAO,SAAS,KAAK,KAAK,MAAM,GAAG,EAAE,CAAC,GAAG,OAAO,SAAS,KAAK,KAAK,MAAM,EAAE,CAAC,CAAC;CAC/G,IAAI,OAAO,KAAK,KAAK,QAAQ,OAAO,CAAC,KAAK,MAAM,KAAK,KAAK;CAC1D,IAAI,KAAK,KAAK,KAAK,QAAQ;EACzB,MAAM,CAAC,QAAQ,SAAS,MAAM,SAAS,KAAK,MAAM,EAAE;EACpD,OAAO,CAAC,QAAQ,KAAK,SAAS,OAAO,KAAK,KAAK,CAAC;CAClD;CACA,MAAM,CAAC,QAAQ,SAAS,MAAM,SAAS,KAAK,OAAO,KAAK,KAAK,KAAK,MAAM;CACxE,OAAO,CAAC,KAAK,SAAS,KAAK,MAAM,MAAM,GAAG,KAAK;AACjD;;AAGA,SAAS,SAAS,SAAkB,MAAc,OAAuB;CACvE,MAAM,QAAQ,QAAQ,QAAQ;CAC9B,IAAI,SAAS,KAAK,QAAQ,OAAO,KAAK;CACtC,KAAK,IAAI,IAAI,QAAQ,GAAG,KAAK,QAAQ,QAAQ,QAAQ,GAAG,KAAK,IAAI,YAAY,SAAS,KAAK,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI;CACtH,MAAM,OAAO,KAAK,WAAW,QAAQ,CAAC;CACtC,OAAO,QAAQ,SAAU,QAAQ,QAAS,QAAQ,IAAI;AACxD;;AAGA,SAAS,MAAM,SAAkB,MAAgC;CAC/D,IAAI,QAAgB,CAAC;CACrB,KAAK,IAAI,QAAQ,GAAG,QAAQ,KAAK,SAAU;EACzC,MAAM,MAAM,SAAS,SAAS,MAAM,KAAK;EACzC,MAAM,KAAK,OAAO,SAAS,KAAK,MAAM,OAAO,GAAG,CAAC,CAAC;EAClD,QAAQ;CACV;CACA,IAAI,MAAM,WAAW,GAAG,OAAO,KAAA;CAC/B,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,OAAe,CAAC;EACtB,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,MAAM,QAAQ,KAAK,GAAG,KAAK,KAAK,SAAS,SAAS,MAAM,IAAK,MAAM,IAAI,EAAG,CAAC;EACnG,IAAI,MAAM,SAAS,MAAM,GAAG,KAAK,KAAK,MAAM,MAAM,SAAS,EAAG;EAC9D,QAAQ;CACV;CACA,OAAO,MAAM;AACf;AAEA,SAAS,OAAO,MAAwB,KAAyB;CAC/D,IAAI,SAAS,KAAA,GAAW,OAAO;CAC/B,MAAM,QAAgB,CAAC,IAAI;CAC3B,OAAO,MAAM,SAAS,GAAG;EACvB,MAAM,MAAM,MAAM,IAAI;EACtB,IAAI,IAAI,SAAS,QAAQ,IAAI,KAAK,IAAI,IAAI;OACrC,MAAM,KAAK,IAAI,OAAO,IAAI,IAAI;CACrC;CACA,OAAO;AACT;;;;;AAMA,IAAa,OAAb,MAAa,KAAK;CAChB;CACA;CAEA,YAAoB,SAAkB,MAAwB;EAC5D,KAAK,WAAW;EAChB,KAAK,QAAQ;CACf;;CAGA,OAAO,KAAK,MAAc,OAAgB,UAAuB,CAAC,GAAS;EACzE,MAAM,aAAa,QAAQ,cAAc;EACzC,MAAM,QAAQ,QAAQ,SAAS;EAC/B,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,GAAG,MAAM,IAAI,WAAW,gBAAgB,MAAM,8BAA8B;EACpH,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;GAC1C,MAAM,OAAO,WAAW,WAAW,CAAC;GACpC,IAAI,QAAQ,SAAU,QAAQ,OAAQ,MAAM,IAAI,WAAW,qEAAqE;EAClI;EACA,MAAM,UAAmB;GAAE;GAAO;GAAY;EAAM;EACpD,OAAO,IAAI,KAAK,SAAS,MAAM,SAAS,IAAI,CAAC;CAC/C;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAK,OAAO,UAAU;CAC/B;;CAGA,IAAI,QAAgB;EAClB,OAAO,KAAK,OAAO,SAAS;CAC9B;;CAGA,IAAI,SAAiB;EACnB,OAAO,KAAK,OAAO,UAAU;CAC/B;;CAGA,WAAmB;EACjB,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE;CACvC;;CAGA,SAAmB;EACjB,OAAO,OAAO,KAAK,OAAO,CAAC,CAAC;CAC9B;;CAGA,MAAM,OAAe,MAAc,KAAK,QAAc;EACpD,KAAK,OAAO,OAAO,GAAG;EACtB,MAAM,GAAG,SAAS,MAAM,KAAK,UAAU,KAAK,OAAO,KAAK;EACxD,MAAM,CAAC,UAAU,MAAM,KAAK,UAAU,OAAO,MAAM,KAAK;EACxD,OAAO,IAAI,KAAK,KAAK,UAAU,MAAM;CACvC;;CAGA,QAAQ,OAAe,MAAc,KAAK,QAAgB;EACxD,OAAO,KAAK,MAAM,OAAO,GAAG,CAAC,CAAC;CAChC;;CAGA,OAAO,OAAmB;EACxB,MAAM,UAAU,MAAM;EACtB,IAAI,QAAQ,UAAU,KAAK,SAAS,SAAS,QAAQ,eAAe,KAAK,SAAS,cAAc,QAAQ,UAAU,KAAK,SAAS,OAC9H,MAAM,IAAI,UAAU,yDAAyD;EAE/E,OAAO,IAAI,KAAK,KAAK,UAAU,KAAK,KAAK,UAAU,KAAK,OAAO,MAAM,KAAK,CAAC;CAC7E;;CAGA,OAAO,IAAY,MAAoB;EACrC,OAAO,KAAK,QAAQ,IAAI,IAAI,IAAI;CAClC;;CAGA,OAAO,OAAe,KAAmB;EACvC,OAAO,KAAK,QAAQ,OAAO,KAAK,EAAE;CACpC;;CAGA,QAAQ,OAAe,KAAa,MAAoB;EACtD,KAAK,OAAO,OAAO,GAAG;EACtB,MAAM,CAAC,QAAQ,QAAQ,MAAM,KAAK,UAAU,KAAK,OAAO,KAAK;EAC7D,MAAM,GAAG,SAAS,MAAM,KAAK,UAAU,MAAM,MAAM,KAAK;EACxD,MAAM,SAAS,MAAM,KAAK,UAAU,IAAI;EACxC,OAAO,IAAI,KAAK,KAAK,UAAU,KAAK,KAAK,UAAU,KAAK,KAAK,UAAU,QAAQ,MAAM,GAAG,KAAK,CAAC;CAChG;CAEA,OAAO,OAAe,KAAmB;EACvC,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,CAAC,OAAO,UAAU,GAAG,KAAK,QAAQ,KAAK,MAAM,SAAS,MAAM,KAAK,QAC/F,MAAM,IAAI,WAAW,aAAa,MAAM,MAAM,IAAI,gCAAgC,KAAK,QAAQ;CAEnG;AACF"}

package/build/index.d.ts

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

package/build/index.js

@@ -1 +1,3 @@
-export { t as breaking } from "./chunks/breaking.js";
+import { t as breaking_exports } from "./chunks/breaking.js";
+import { t as text_exports } from "./chunks/text.js";
+export { breaking_exports as breaking, text_exports as text };

package/build/text.d.ts

@@ -0,0 +1,2 @@
+import { n as Text, r as TextOptions } from "./chunks/text.js";
+export { Text, type TextOptions };

package/build/text.js

@@ -0,0 +1 @@
+export { n as Text } from "./chunks/text.js";

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/typeset",
-  "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.",
+  "version": "0.1.1",
+  "description": "Text measurement and line breaking. The subpath ./breaking has the line breakers, and ./text has a rope with the width of each part, for any width function.",
   "keywords": [
     "typeset",
     "line-breaking",
@@ -34,6 +34,10 @@
       "types": "./build/breaking.d.ts",
       "default": "./build/breaking.js"
     },
+    "./text": {
+      "types": "./build/text.d.ts",
+      "default": "./build/text.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -50,7 +54,8 @@
   },
   "devDependencies": {
     "@mark1russell7/cue": "^1.0.2",
-    "@mark1russell7/layout-contract": "^0.2.21",
+    "@mark1russell7/layout-contract": "^0.3.2",
+    "@mark1russell7/rigor-generators": "^0.1.0",
     "@types/node": "^26.6.5",
     "@typeset/corpus": "0.1.0",
     "tsdown": "^0.23.1",

package/src/index.ts

@@ -3,3 +3,4 @@
  * `@mark1russell7/typeset/breaking`. This entry gives each area as one namespace.
  */
 export * as breaking from "./breaking.ts";
+export * as text from "./text.ts";

package/src/text/rope.ts

@@ -0,0 +1,291 @@
+/**
+ * The `Text` rope: a persistent balanced tree of strings with the width and the length of each subtree. An edit makes a
+ * new rope. The new rope shares the subtrees that do not change. A width function gives the width of a run of text. The
+ * rope uses it only for the leaves and for the windows at the seams. Thus an edit uses it of the order of `log n` times.
+ *
+ * The seams are exact when the width function obeys the separator law. For each text `p + s + q` with a separator `s`:
+ * `width(p + s + q) = width(p + s) + width(s + q) - width(s)`. The model of `@typeset/fonts` obeys it for a space and a
+ * tab. It shapes each word alone, and its kerning goes only between two adjacent glyphs.
+ */
+import type { WidthOf } from "../breaking/paragraph.ts";
+
+/** The options of a rope. */
+export interface TextOptions {
+  /**
+   * The separators of the separator law: each character is one UTF-16 code unit. The default is a space and a tab. An
+   * empty string makes each seam measure the full text of the two sides.
+   */
+  readonly separators?: string;
+  /** The largest count of UTF-16 code units in a leaf. The default is 256. */
+  readonly chunk?: number;
+}
+
+/** The summary of a subtree: its length, its width, and the two ends that a seam measures again. */
+interface Summary {
+  /** The count of UTF-16 code units. */
+  readonly length: number;
+  readonly width: number;
+  /** This value is `true` when the text has a separator. */
+  readonly separated: boolean;
+  /** The text through the first separator, or all the text when the text has no separator. */
+  readonly head: string;
+  readonly headWidth: number;
+  /** The text from the last separator, or all the text when the text has no separator. */
+  readonly tail: string;
+  readonly tailWidth: number;
+}
+
+interface Leaf extends Summary {
+  readonly kind: "leaf";
+  readonly text: string;
+  readonly height: 0;
+}
+
+interface Branch extends Summary {
+  readonly kind: "branch";
+  readonly left: Node;
+  readonly right: Node;
+  readonly height: number;
+}
+
+type Node = Leaf | Branch;
+
+/** The shared state of the ropes of one width function and one set of options. */
+interface Context {
+  readonly width: WidthOf;
+  readonly separators: string;
+  readonly chunk: number;
+}
+
+function isSeparator(context: Context, code: number): boolean {
+  for (let i = 0; i < context.separators.length; i++) if (context.separators.charCodeAt(i) === code) return true;
+  return false;
+}
+
+function leafOf(context: Context, text: string): Leaf {
+  const width = context.width(text);
+  let first = -1;
+  let last = -1;
+  for (let i = 0; i < text.length; i++) {
+    if (!isSeparator(context, text.charCodeAt(i))) continue;
+    if (first < 0) first = i;
+    last = i;
+  }
+  if (first < 0) return { kind: "leaf", text, height: 0, length: text.length, width, separated: false, head: text, headWidth: width, tail: text, tailWidth: width };
+  const head = text.slice(0, first + 1);
+  const tail = text.slice(last);
+  return { kind: "leaf", text, height: 0, length: text.length, width, separated: true, head, headWidth: context.width(head), tail, tailWidth: context.width(tail) };
+}
+
+/**
+ * This function makes the branch of two subtrees. It measures one window: the tail of the left side and the head of the right
+ * side. The separator law then gives the width of all the text from the widths of the two sides.
+ */
+function branchOf(context: Context, left: Node, right: Node): Branch {
+  const seam = left.tail + right.head;
+  const seamWidth = context.width(seam);
+  let width: number;
+  if (!left.separated && !right.separated) width = seamWidth;
+  else if (!left.separated) width = right.width - right.headWidth + seamWidth;
+  else if (!right.separated) width = left.width - left.tailWidth + seamWidth;
+  else width = left.width + right.width - left.tailWidth - right.headWidth + seamWidth;
+  return {
+    kind: "branch",
+    left,
+    right,
+    height: Math.max(left.height, right.height) + 1,
+    length: left.length + right.length,
+    width,
+    separated: left.separated || right.separated,
+    head: left.separated ? left.head : seam,
+    headWidth: left.separated ? left.headWidth : seamWidth,
+    tail: right.separated ? right.tail : seam,
+    tailWidth: right.separated ? right.tailWidth : seamWidth,
+  };
+}
+
+/** This function joins two trees in the order of the text and keeps the heights of the two children within 1. */
+function join(context: Context, left: Node | undefined, right: Node | undefined): Node | undefined {
+  if (left === undefined) return right;
+  if (right === undefined) return left;
+  if (left.kind === "leaf" && right.kind === "leaf" && left.length + right.length <= context.chunk) return leafOf(context, left.text + right.text);
+  if (left.height > right.height + 1) {
+    const branch = left as Branch;
+    const joined = join(context, branch.right, right)!;
+    if (joined.height <= branch.left.height + 1) return branchOf(context, branch.left, joined);
+    return rotateLeft(context, branch.left, joined as Branch);
+  }
+  if (right.height > left.height + 1) {
+    const branch = right as Branch;
+    const joined = join(context, left, branch.left)!;
+    if (joined.height <= branch.right.height + 1) return branchOf(context, joined, branch.right);
+    return rotateRight(context, joined as Branch, branch.right);
+  }
+  return branchOf(context, left, right);
+}
+
+/** This function balances the branch of `left` and `heavy`, when `heavy` is 2 levels higher than `left`. */
+function rotateLeft(context: Context, left: Node, heavy: Branch): Branch {
+  if (heavy.left.height <= heavy.right.height) return branchOf(context, branchOf(context, left, heavy.left), heavy.right);
+  const middle = heavy.left as Branch;
+  return branchOf(context, branchOf(context, left, middle.left), branchOf(context, middle.right, heavy.right));
+}
+
+/** This function balances the branch of `heavy` and `right`, when `heavy` is 2 levels higher than `right`. */
+function rotateRight(context: Context, heavy: Branch, right: Node): Branch {
+  if (heavy.right.height <= heavy.left.height) return branchOf(context, heavy.left, branchOf(context, heavy.right, right));
+  const middle = heavy.right as Branch;
+  return branchOf(context, branchOf(context, heavy.left, middle.left), branchOf(context, middle.right, right));
+}
+
+/** This function divides a tree at the UTF-16 offset `at` into the text before and the text after. */
+function split(context: Context, node: Node | undefined, at: number): [Node | undefined, Node | undefined] {
+  if (node === undefined) return [undefined, undefined];
+  if (at <= 0) return [undefined, node];
+  if (at >= node.length) return [node, undefined];
+  if (node.kind === "leaf") return [leafOf(context, node.text.slice(0, at)), leafOf(context, node.text.slice(at))];
+  if (at === node.left.length) return [node.left, node.right];
+  if (at < node.left.length) {
+    const [before, after] = split(context, node.left, at);
+    return [before, join(context, after, node.right)];
+  }
+  const [before, after] = split(context, node.right, at - node.left.length);
+  return [join(context, node.left, before), after];
+}
+
+/** This function gives the end of the next leaf of `text` from `start`: after a separator when it can, and not in a surrogate pair. */
+function chunkEnd(context: Context, text: string, start: number): number {
+  const limit = start + context.chunk;
+  if (limit >= text.length) return text.length;
+  for (let i = limit - 1; i >= start + context.chunk / 2; i--) if (isSeparator(context, text.charCodeAt(i))) return i + 1;
+  const code = text.charCodeAt(limit - 1);
+  return code >= 0xd800 && code <= 0xdbff ? limit - 1 : limit;
+}
+
+/** This function makes a balanced tree of a text: leaves of at most `chunk` code units, and then a level of branches at a time. */
+function build(context: Context, text: string): Node | undefined {
+  let level: Node[] = [];
+  for (let start = 0; start < text.length; ) {
+    const end = chunkEnd(context, text, start);
+    level.push(leafOf(context, text.slice(start, end)));
+    start = end;
+  }
+  if (level.length === 0) return undefined;
+  while (level.length > 1) {
+    const next: Node[] = [];
+    for (let i = 0; i + 1 < level.length; i += 2) next.push(branchOf(context, level[i]!, level[i + 1]!));
+    if (level.length % 2 === 1) next.push(level[level.length - 1]!);
+    level = next;
+  }
+  return level[0];
+}
+
+function leaves(node: Node | undefined, out: string[]): string[] {
+  if (node === undefined) return out;
+  const stack: Node[] = [node];
+  while (stack.length > 0) {
+    const top = stack.pop()!;
+    if (top.kind === "leaf") out.push(top.text);
+    else stack.push(top.right, top.left);
+  }
+  return out;
+}
+
+/**
+ * A text with its width: a persistent balanced rope. Each edit gives a new `Text` and does not change this one. The offsets
+ * are in UTF-16 code units, as the offsets of a JavaScript string.
+ */
+export class Text {
+  readonly #context: Context;
+  readonly #root: Node | undefined;
+
+  private constructor(context: Context, root: Node | undefined) {
+    this.#context = context;
+    this.#root = root;
+  }
+
+  /** This function makes the rope of `text` with the width function `width`. */
+  static from(text: string, width: WidthOf, options: TextOptions = {}): Text {
+    const separators = options.separators ?? " \t";
+    const chunk = options.chunk ?? 256;
+    if (!Number.isInteger(chunk) || chunk < 2) throw new RangeError(`the chunk is ${chunk}, not an integer of 2 or more`);
+    for (let i = 0; i < separators.length; i++) {
+      const code = separators.charCodeAt(i);
+      if (code >= 0xd800 && code <= 0xdfff) throw new RangeError("a separator is one UTF-16 code unit, not a half of a surrogate pair");
+    }
+    const context: Context = { width, separators, chunk };
+    return new Text(context, build(context, text));
+  }
+
+  /** The count of UTF-16 code units of the text. */
+  get length(): number {
+    return this.#root?.length ?? 0;
+  }
+
+  /** The width of the text. It is equal to the width of the flat string when the width function obeys the separator law. */
+  get width(): number {
+    return this.#root?.width ?? 0;
+  }
+
+  /** The height of the tree: 0 for a text of one leaf. The tests use it to examine the balance. */
+  get height(): number {
+    return this.#root?.height ?? 0;
+  }
+
+  /** This function gives the flat string. */
+  toString(): string {
+    return leaves(this.#root, []).join("");
+  }
+
+  /** This function gives the strings of the leaves in the order of the text. */
+  chunks(): string[] {
+    return leaves(this.#root, []);
+  }
+
+  /** This function gives the text from `start` to `end`, as a new rope. */
+  slice(start: number, end: number = this.length): Text {
+    this.#check(start, end);
+    const [, after] = split(this.#context, this.#root, start);
+    const [middle] = split(this.#context, after, end - start);
+    return new Text(this.#context, middle);
+  }
+
+  /** This function gives the width of the text from `start` to `end`. */
+  widthOf(start: number, end: number = this.length): number {
+    return this.slice(start, end).width;
+  }
+
+  /** This function gives this text and then `other`. The two ropes must have the same width function and options. */
+  concat(other: Text): Text {
+    const context = other.#context;
+    if (context.width !== this.#context.width || context.separators !== this.#context.separators || context.chunk !== this.#context.chunk) {
+      throw new TypeError("the two ropes have different width functions or options");
+    }
+    return new Text(this.#context, join(this.#context, this.#root, other.#root));
+  }
+
+  /** This function puts `text` at the offset `at`. */
+  insert(at: number, text: string): Text {
+    return this.replace(at, at, text);
+  }
+
+  /** This function removes the text from `start` to `end`. */
+  remove(start: number, end: number): Text {
+    return this.replace(start, end, "");
+  }
+
+  /** This function puts `text` in place of the text from `start` to `end`. */
+  replace(start: number, end: number, text: string): Text {
+    this.#check(start, end);
+    const [before, rest] = split(this.#context, this.#root, start);
+    const [, after] = split(this.#context, rest, end - start);
+    const middle = build(this.#context, text);
+    return new Text(this.#context, join(this.#context, join(this.#context, before, middle), after));
+  }
+
+  #check(start: number, end: number): void {
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end < start || end > this.length) {
+      throw new RangeError(`the range ${start} to ${end} is not in the text of length ${this.length}`);
+    }
+  }
+}

package/src/text.ts

@@ -0,0 +1 @@
+export { Text, type TextOptions } from "./text/rope.ts";