@mark1russell7/typeset 0.1.0 → 0.1.2

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 `@mark1russell7/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":"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"}

package/build/fonts-inspect.d.ts

@@ -0,0 +1,10 @@
+import { i as glyphAdvances, s as shapingWords, u as defaultFeatures } from "./chunks/font.js";
+import { n as readTables } from "./chunks/sfnt.js";
+/**
+ * This function divides the text of a canvas into the words that Blink shapes one at a time. Each space, tab and zero
+ * width space is a word alone. Each CJK character starts a word, with its marks and the CJK characters of the script
+ * Common after it.
+ */
+export declare function canvasWords(text: string): string[];
+export { defaultFeatures, glyphAdvances, readTables, shapingWords };
+//# sourceMappingURL=fonts-inspect.d.ts.map

package/build/fonts-inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fonts-inspect.d.ts","names":[],"sources":["../src/fonts/words.ts"],"mappings":";;;;;;;wBAwDgB,YAAY"}

package/build/fonts-inspect.js

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

package/build/fonts.d.ts

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

package/build/fonts.js

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

package/build/index.d.ts

@@ -1,2 +1,5 @@
 import { t as breaking_d_exports } from "./chunks/breaking.js";
-export { breaking_d_exports as breaking };
+import { t as fonts_d_exports } from "./chunks/fonts.js";
+import { t as measurer_d_exports } from "./chunks/measurer.js";
+import { t as text_d_exports } from "./chunks/text.js";
+export { breaking_d_exports as breaking, fonts_d_exports as fonts, measurer_d_exports as measurer, text_d_exports as text };

package/build/index.js

@@ -1 +1,5 @@
-export { t as breaking } from "./chunks/breaking.js";
+import { t as breaking_exports } from "./chunks/breaking.js";
+import { t as fonts_exports } from "./chunks/fonts.js";
+import { t as measurer_exports } from "./chunks/measurer.js";
+import { t as text_exports } from "./chunks/text.js";
+export { breaking_exports as breaking, fonts_exports as fonts, measurer_exports as measurer, text_exports as text };

package/build/measurer.d.ts

@@ -0,0 +1,2 @@
+import { a as fontAdvance, i as FontSpec, n as FontAdvanceOptions, o as parseFont, r as FontFace, s as scriptTag } from "./chunks/measurer.js";
+export { type FontAdvanceOptions, type FontFace, type FontSpec, fontAdvance, parseFont, scriptTag };

package/build/measurer.js

@@ -0,0 +1 @@
+export { n as fontAdvance, r as parseFont, i as scriptTag } from "./chunks/measurer.js";

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.2",
+  "description": "Text measurement and line breaking. The subpath ./fonts reads font tables and gives widths, ./measurer gives the advance function of a layout, ./breaking has the line breakers, and ./text has a rope.",
   "keywords": [
     "typeset",
     "line-breaking",
@@ -34,6 +34,22 @@
       "types": "./build/breaking.d.ts",
       "default": "./build/breaking.js"
     },
+    "./fonts": {
+      "types": "./build/fonts.d.ts",
+      "default": "./build/fonts.js"
+    },
+    "./fonts/inspect": {
+      "types": "./build/fonts-inspect.d.ts",
+      "default": "./build/fonts-inspect.js"
+    },
+    "./measurer": {
+      "types": "./build/measurer.d.ts",
+      "default": "./build/measurer.js"
+    },
+    "./text": {
+      "types": "./build/text.d.ts",
+      "default": "./build/text.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -48,9 +64,12 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@mark1russell7/rigor-generators": "^0.1.0"
+  },
   "devDependencies": {
     "@mark1russell7/cue": "^1.0.2",
-    "@mark1russell7/layout-contract": "^0.2.21",
+    "@mark1russell7/layout-contract": "^0.3.2",
     "@types/node": "^26.6.5",
     "@typeset/corpus": "0.1.0",
     "tsdown": "^0.23.1",

package/src/fonts/bidi.ts

@@ -0,0 +1,125 @@
+/**
+ * A small model of the Unicode Bidirectional Algorithm (UAX #9) for one paragraph with the base level 0. Blink adds the
+ * widths of the words of a canvas in the visual order, so the single-precision sum needs this order. The model has no
+ * explicit embeddings, no isolates and no brackets (rule N0). It gets the bidi class of a character from its script and
+ * its general category, so it knows the classes of the common characters only.
+ */
+
+/** A bidi class of UAX #9. */
+type BidiClass = "L" | "R" | "AL" | "EN" | "ES" | "ET" | "AN" | "CS" | "NSM" | "BN" | "B" | "S" | "WS" | "ON";
+
+const nonSpacingMark = /[\p{Mn}\p{Me}]/u;
+const currency = /\p{Sc}/u;
+const format = /\p{Cf}/u;
+const hebrew = /\p{Script_Extensions=Hebrew}/u;
+const arabicLetter = /[\p{Script_Extensions=Arabic}\p{Script_Extensions=Syriac}\p{Script_Extensions=Thaana}]/u;
+const letter = /[\p{L}\p{Mc}]/u;
+const commonSeparators: ReadonlySet<number> = new Set([0x2c, 0x2e, 0x2f, 0x3a, 0xa0, 0x60c, 0x202f, 0x2044]);
+
+/** This function gives the bidi class of a character, from its code point, its script and its general category. */
+function bidiClass(character: string): BidiClass {
+  const c = character.codePointAt(0)!;
+  if (nonSpacingMark.test(character)) return "NSM";
+  if ((c >= 0x30 && c <= 0x39) || (c >= 0x6f0 && c <= 0x6f9) || c === 0xb2 || c === 0xb3 || c === 0xb9 || (c >= 0xff10 && c <= 0xff19)) return "EN";
+  if ((c >= 0x660 && c <= 0x669) || c === 0x66b || c === 0x66c) return "AN";
+  if (c === 0x2b || c === 0x2d || c === 0x2212) return "ES";
+  if (c === 0x23 || c === 0x25 || c === 0xb0 || c === 0x2030 || currency.test(character)) return "ET";
+  if (commonSeparators.has(c)) return "CS";
+  if (c === 0x9 || c === 0xb || c === 0x1f) return "S";
+  if (c === 0xa || c === 0xd || (c >= 0x1c && c <= 0x1e) || c === 0x85 || c === 0x2029) return "B";
+  if (c === 0x20 || c === 0xc || (c >= 0x2000 && c <= 0x200a) || c === 0x2028 || c === 0x3000) return "WS";
+  if (format.test(character)) return "BN";
+  if (hebrew.test(character)) return "R";
+  if (arabicLetter.test(character)) return "AL";
+  return letter.test(character) ? "L" : "ON";
+}
+
+/** This function gives the direction of a strong class for the rule N1: `EN` and `AN` count as `R`. */
+function strongDirection(type: BidiClass): "L" | "R" | undefined {
+  if (type === "L") return "L";
+  return type === "R" || type === "EN" || type === "AN" ? "R" : undefined;
+}
+
+/**
+ * This function gives the bidi level of each code point of a text, in a paragraph with the base level 0. It applies the
+ * rules W1 to W7, N1, N2, I1 and L1 of UAX #9.
+ */
+export function bidiLevels(text: string): number[] {
+  const characters = [...text];
+  const original = characters.map(bidiClass);
+  const types = [...original];
+  const n = types.length;
+  // W1: a mark gets the class of the character before it
+  for (let i = 0; i < n; i++) if (types[i] === "NSM") types[i] = i === 0 || types[i - 1] === "BN" ? "L" : types[i - 1]!;
+  // W2 and W3: a European digit after an Arabic letter is an Arabic digit, and an Arabic letter is R
+  let strong: BidiClass = "L";
+  for (let i = 0; i < n; i++) {
+    const type = types[i]!;
+    if (type === "L" || type === "R" || type === "AL") strong = type;
+    else if (type === "EN" && strong === "AL") types[i] = "AN";
+  }
+  for (let i = 0; i < n; i++) if (types[i] === "AL") types[i] = "R";
+  // W4: one separator between two digits of the same class gets their class
+  for (let i = 1; i + 1 < n; i++) {
+    const before = types[i - 1]!;
+    if (types[i] === "ES" && before === "EN" && types[i + 1] === "EN") types[i] = "EN";
+    else if (types[i] === "CS" && (before === "EN" || before === "AN") && types[i + 1] === before) types[i] = before;
+  }
+  // W5: a sequence of terminators next to a European digit is EN
+  for (let i = 0; i < n; i++) {
+    if (types[i] !== "ET") continue;
+    let end = i;
+    while (end < n && types[end] === "ET") end++;
+    if ((i > 0 && types[i - 1] === "EN") || (end < n && types[end] === "EN")) types.fill("EN", i, end);
+    i = end - 1;
+  }
+  // W6 and W7: the other separators and terminators are ON, and a European digit after L is L
+  for (let i = 0; i < n; i++) if (types[i] === "ES" || types[i] === "ET" || types[i] === "CS") types[i] = "ON";
+  strong = "L";
+  for (let i = 0; i < n; i++) {
+    const type = types[i]!;
+    if (type === "L" || type === "R") strong = type;
+    else if (type === "EN" && strong === "L") types[i] = "L";
+  }
+  // N1 and N2: a sequence of neutrals gets the direction of the strong characters on its two sides, or else L
+  for (let i = 0; i < n; i++) {
+    if (strongDirection(types[i]!) !== undefined) continue;
+    let end = i;
+    while (end < n && strongDirection(types[end]!) === undefined) end++;
+    const before = i === 0 ? "L" : strongDirection(types[i - 1]!)!;
+    const after = end === n ? "L" : strongDirection(types[end]!)!;
+    types.fill(before === after ? before : "L", i, end);
+    i = end - 1;
+  }
+  // I1: R goes up one level, and the digits go up two levels
+  const levels = types.map((type) => (type === "R" ? 1 : type === "AN" || type === "EN" ? 2 : 0));
+  // L1: the white space at the end and before each separator goes back to the base level
+  const isSpace = (i: number) => original[i] === "WS" || original[i] === "BN";
+  for (let i = n - 1; i >= 0 && isSpace(i); i--) levels[i] = 0;
+  for (let i = 0; i < n; i++) {
+    if (original[i] !== "S" && original[i] !== "B") continue;
+    levels[i] = 0;
+    for (let k = i - 1; k >= 0 && isSpace(k); k--) levels[k] = 0;
+  }
+  return levels;
+}
+
+/**
+ * This function puts items in the visual order of the rule L2 of UAX #9. Each item has the level `levels[i]`. From the
+ * highest level to the level 1, it reverses each sequence of items at that level or higher.
+ */
+export function visualOrder<T>(items: readonly T[], levels: readonly number[]): T[] {
+  const order = items.map((_, i) => i);
+  const at = [...levels];
+  for (let level = Math.max(0, ...levels); level >= 1; level--) {
+    for (let i = 0; i < order.length; i++) {
+      if (at[i]! < level) continue;
+      let end = i;
+      while (end < order.length && at[end]! >= level) end++;
+      order.splice(i, end - i, ...order.slice(i, end).reverse());
+      at.splice(i, end - i, ...at.slice(i, end).reverse());
+      i = end;
+    }
+  }
+  return order.map((i) => items[i]!);
+}

package/src/fonts/binary.ts

@@ -0,0 +1,41 @@
+/** A big-endian reader over a part of a font file. The offsets are relative to the start of the part. */
+export class Reader {
+  readonly bytes: Uint8Array;
+  private readonly view: DataView;
+
+  constructor(bytes: Uint8Array) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+
+  get length(): number {
+    return this.bytes.byteLength;
+  }
+
+  u8(offset: number): number {
+    return this.view.getUint8(offset);
+  }
+
+  u16(offset: number): number {
+    return this.view.getUint16(offset);
+  }
+
+  i16(offset: number): number {
+    return this.view.getInt16(offset);
+  }
+
+  u32(offset: number): number {
+    return this.view.getUint32(offset);
+  }
+
+  tag(offset: number): string {
+    return String.fromCharCode(this.u8(offset), this.u8(offset + 1), this.u8(offset + 2), this.u8(offset + 3));
+  }
+
+  /** This method gives a reader over the bytes from `offset`, with the length `length` or to the end. */
+  part(offset: number, length?: number): Reader {
+    const end = length === undefined ? this.bytes.byteLength : offset + length;
+    if (offset < 0 || end > this.bytes.byteLength || offset > end) throw new RangeError(`the part ${offset}..${end} is outside ${this.bytes.byteLength} bytes`);
+    return new Reader(this.bytes.subarray(offset, end));
+  }
+}

package/src/fonts/engines.ts

@@ -0,0 +1,38 @@
+/**
+ * The rules of one text engine for the widths of a font. The fields `deltas` and `metrics` are options of `readFont`, and
+ * the fields `rounding` and `sum` are options of `measureWidth`. Thus a caller spreads the same row into the two calls.
+ */
+export interface EngineRules {
+  /** The rounding of the `HVAR` and `gvar` deltas of an instance. */
+  readonly deltas: "round" | "exact";
+  /** The advance of a composite glyph: its own advance, or the advance of its component with the flag USE_MY_METRICS. */
+  readonly metrics: "own" | "component";
+  /** The rounding of each advance: `pixel` rounds it to whole px, and `exact` keeps the fraction. */
+  readonly rounding: "exact" | "pixel";
+  /**
+   * The sum of the advances: `exact`, or `float32` as Blink adds the widths of the words of a canvas in single precision.
+   * A sum of whole px is exact in single precision, so the rounding `pixel` needs no `float32` sum.
+   */
+  readonly sum: "exact" | "float32";
+}
+
+/**
+ * The rules of the text engines of Chromium, one row for each engine. The fonts runs of typeset#27 measured each row
+ * against the canvas, and the T1d diagnosis of the sum measured the field `sum`. A new engine is a new row.
+ */
+export const engines: { readonly freetype: EngineRules; readonly coretext: EngineRules; readonly directwrite: EngineRules } = {
+  /** FreeType, as Chromium on Linux uses it: rounded deltas, and each advance in whole px. */
+  freetype: { deltas: "round", metrics: "own", rounding: "pixel", sum: "exact" },
+  /** CoreText on macOS: it keeps the fraction of the deltas. */
+  coretext: { deltas: "exact", metrics: "own", rounding: "exact", sum: "float32" },
+  /** DirectWrite on Windows: a composite glyph has the advance of its USE_MY_METRICS component. */
+  directwrite: { deltas: "round", metrics: "component", rounding: "exact", sum: "float32" },
+};
+
+/** The name of a text engine of the table `engines`. */
+export type EngineName = keyof typeof engines;
+
+/** This function tells if a text is the name of an engine of the table `engines`. */
+export function isEngineName(name: string): name is EngineName {
+  return Object.hasOwn(engines, name);
+}