@mark1russell7/typeset 0.1.1 → 0.1.3

package/build/chunks/text.js.map

@@ -1 +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":"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"}
+{"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":";;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/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 { o as canvasWords, u as defaultFeatures, t as glyphAdvances, d as readTables, a 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 { n as WidthBound, r as widthBound } from "./chunks/fonts.js";
+import { i as isEngineName, n as EngineRules, r as engines, t as EngineName } from "./chunks/engines.js";
+export { type Axis, type Decompress, type EngineName, type EngineRules, type Font, type Instance, type MeasureOptions, type ReadOptions, type WidthBound, engines, isEngineName, measureWidth, readFont, widthBound };

package/build/fonts.js

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

package/build/index.d.ts

@@ -1,3 +1,5 @@
 import { t as breaking_d_exports } from "./chunks/breaking.js";
+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, text_d_exports as text };
+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,3 +1,5 @@
 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, text_exports as text };
+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/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@mark1russell7/typeset",
-  "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.",
+  "version": "0.1.3",
+  "description": "Text measurement and line breaking. The subpath ./fonts reads font tables and gives widths, ./measurer gives the advance function of a layout, ./breaking has the line breakers, and ./text has a rope.",
   "keywords": [
     "typeset",
     "line-breaking",
@@ -34,6 +34,18 @@
       "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"
@@ -52,10 +64,12 @@
   "publishConfig": {
     "access": "public"
   },
+  "dependencies": {
+    "@mark1russell7/rigor-generators": "^0.1.0"
+  },
   "devDependencies": {
-    "@mark1russell7/cue": "^1.0.2",
+    "@mark1russell7/cue": "^2.0.0",
     "@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/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/bound.ts

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

package/src/fonts/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);
+}