@mark1russell7/typeset 0.1.0 → 0.1.2

package/README.md

@@ -5,6 +5,9 @@ This package measures text and breaks it into lines. Each area has its own subpa
 | Subpath | What it has |
 | --- | --- |
 | `@mark1russell7/typeset/breaking` | The paragraph model of boxes, glue and penalties, and the greedy, total fit and balanced line breakers. |
+| `@mark1russell7/typeset/fonts` | The font model: it reads a font file and gives the width of a text as a browser engine gives it. |
+| `@mark1russell7/typeset/measurer` | `fontAdvance`: the advance function of a layout engine, from the font files of the host. |
+| `@mark1russell7/typeset/text` | The `Text` rope: a text with its width, and edits that measure only the changed parts. |
 
 ## Line breaking
 
@@ -20,4 +23,39 @@ const lines = linesOf(paragraph, knuthPlass.breaks(paragraph, 120));
 - `greedy` fills each line as a browser does. `knuthPlass` chooses the breaks with the least sum of demerits. `balanced` keeps the greedy line count with more equal lines.
 - The option `hyphenate` gives the offsets of the hyphen breaks of a word.
 
+## The Text rope
+
+```ts
+import { Text } from "@mark1russell7/typeset/text";
+
+const widthOf = (text: string): number => 8 * [...text].length;
+const text = Text.from("The quick brown fox", widthOf);
+const edited = text.insert(4, "very ").remove(0, 4);
+console.log(edited.toString(), edited.width);
+```
+
+- Each edit gives a new rope. The old rope does not change, and the two share the parts that the edit does not touch.
+- An edit uses the width function of the order of `log n` times, on the changed leaves and on short windows.
+- The width is exact when the width function obeys the separator law: `width(p + s + q) = width(p + s) + width(s + q) - width(s)`.
+- The separator `s` is a space or a tab. The option `separators` changes the set.
+- The font model of `./fonts` obeys the law for its shaping `dom` and `canvas`, with the sum `exact`.
+
+## The font model and the measurer
+
+```ts
+import { readFileSync } from "node:fs";
+import { createMeasurer, layoutText } from "@mark1russell7/layout-contract/text";
+import { fontAdvance } from "@mark1russell7/typeset/measurer";
+
+const advance = fontAdvance({ faces: [{ family: "Noto Sans", data: readFileSync("NotoSans.ttf") }], engine: "freetype" });
+const layout = layoutText("The quick brown fox", { font: "16px Noto Sans", measurer: createMeasurer(advance), lineHeight: 20, wrapWidth: 80 });
+```
+
+- The host gives the bytes of each font file. The package has no font file.
+- `fontAdvance` reads the CSS font, and finds the face with the CSS rules of the family, the style and the weight.
+- Each run of the text gets the first family with a glyph for its first character.
+- The width of a run is `measureWidth` of `./fonts`, with the script of the run and the rules of one engine of `engines`.
+- The engine rows are `freetype` (Chromium on Linux), `coretext` (macOS) and `directwrite` (Windows).
+- `readFont` reads TrueType, OpenType and WOFF2 files. A WOFF2 file needs a Brotli decompress function, for example `brotliDecompressSync` of `node:zlib`.
+
 The repository [mark1russell7/typeset](https://github.com/mark1russell7/typeset) has the report of the breakers in `docs/BREAKING.md`.

package/build/breaking.d.ts

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

package/build/chunks/breaking.d.ts

@@ -1,79 +1,4 @@
-/**
- * The paragraph model of the breakers: a list of boxes, glue and penalties, as Knuth and Plass define it. A builder makes
- * the items of a text. The breakers read only the items, so a new rule of break opportunities is a new builder.
- */
-/** A width function: the width of a run of text, in any unit. The breakers add the widths and compare them. */
-type WidthOf = (text: string) => number;
-/** A box: text that the breaker does not break. */
-interface Box {
-  readonly type: "box";
-  readonly text: string;
-  readonly width: number;
-}
-/** Glue: a space between two boxes. A line can end at glue that comes after a box. The line then does not show the glue. */
-interface Glue {
-  readonly type: "glue";
-  readonly text: string;
-  readonly width: number;
-}
-/**
- * A penalty: a break opportunity with a cost. A line that ends at the penalty shows its text, for example a hyphen. A cost of
- * `Infinity` forbids the break, and a cost of `-Infinity` forces it.
- */
-interface Penalty {
-  readonly type: "penalty";
-  readonly text: string;
-  readonly width: number;
-  readonly cost: number;
-  /** A flagged penalty is a hyphen. Total fit adds a cost to two flagged breaks in sequence. */
-  readonly flagged: boolean;
-}
-/** An item of a paragraph. */
-type Item = Box | Glue | Penalty;
-/** A paragraph: the items in the order of the text. */
-interface Paragraph {
-  readonly items: readonly Item[];
-}
-/** The options of `paragraphOf`. */
-interface ParagraphOptions {
-  /** The width function of the boxes, the spaces and the hyphens. */
-  readonly widthOf: WidthOf;
-  /**
-   * The hyphenation hook. It gives the offsets in a word where a break with a hyphen is possible. The default gives no
-   * offset. The width of each part of a word comes from `widthOf`, so the kerning across an offset is not in the sum.
-   */
-  readonly hyphenate?: (word: string) => readonly number[];
-  /** The text that a line shows at a hyphen break. The default is "-". */
-  readonly hyphen?: string;
-  /** The cost of a hyphen break. The default is 50, as in TeX. */
-  readonly hyphenCost?: number;
-}
-/**
- * This function makes the paragraph of a text with the break opportunities of CSS `white-space: normal`. Each run of white
- * space becomes one glue of the width of a space. Each word between two runs becomes a box, or boxes and hyphen penalties.
- */
-declare function paragraphOf(text: string, options: ParagraphOptions): Paragraph;
-/** A line of a broken paragraph. */
-interface Line {
-  readonly text: string;
-  /** The width of the line: its boxes, the glue between them and the text of a penalty at its end. */
-  readonly width: number;
-  /** The index of the first item of the line. */
-  readonly start: number;
-  /** The index after the last item of the line. A break at glue or at a penalty has the index of that item. */
-  readonly end: number;
-}
-/** This function tells if a line can end at the item `index`: glue after a box, or a penalty with a cost below `Infinity`. */
-declare function isBreak(items: readonly Item[], index: number): boolean;
-/** This function gives the index of the first item of a line after a break at `index`. It skips the glue and the penalties. */
-declare function lineStart(items: readonly Item[], index: number): number;
-/** This function gives the width of the line from the item `start` to a break at `end`, with the text of a penalty at `end`. */
-declare function lineWidth(items: readonly Item[], start: number, end: number): number;
-/**
- * This function gives the lines of a paragraph from the indices of its breaks. Each break is the index of glue or of a penalty.
- * The last line ends at the end of the items.
- */
-declare function linesOf(paragraph: Paragraph, breaks: readonly number[]): Line[];
+import { a as Paragraph, c as WidthOf, d as lineWidth, f as linesOf, i as Line, l as isBreak, n as Glue, o as ParagraphOptions, p as paragraphOf, r as Item, s as Penalty, t as Box, u as lineStart } from "./paragraph.js";
 /**
  * A breaker: a strategy that chooses the breaks of a paragraph for the line width `width`. It gives the indices of the
  * items where the lines end, in order. A breaker reads only the items, so any width function and any builder work with it.
@@ -126,5 +51,5 @@ declare function spread(lines: readonly Line[]): number;
 declare namespace breaking_d_exports {
   export { BalancedOptions, Box, Breaker, Glue, Item, Line, Paragraph, ParagraphOptions, Penalty, TotalFitOptions, WidthOf, balanced, balancedBreaker, breakers, greedy, isBreak, knuthPlass, lineStart, lineWidth, linesOf, paragraphOf, raggedness, spread, totalFit };
 }
-export { lineWidth as C, lineStart as S, paragraphOf as T, Paragraph as _, Breaker as a, WidthOf as b, balancedBreaker as c, knuthPlass as d, totalFit as f, Line as g, Item as h, BalancedOptions as i, breakers as l, Glue as m, raggedness as n, TotalFitOptions as o, Box as p, spread as r, balanced as s, breaking_d_exports as t, greedy as u, ParagraphOptions as v, linesOf as w, isBreak as x, Penalty as y };
+export { Breaker as a, balancedBreaker as c, knuthPlass as d, totalFit as f, BalancedOptions as i, breakers as l, raggedness as n, TotalFitOptions as o, spread as r, balanced as s, breaking_d_exports as t, greedy as u };
 //# sourceMappingURL=breaking.d.ts.map

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

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

package/build/chunks/engines.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+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.
+ */
+declare const engines: {
+  readonly freetype: EngineRules;
+  readonly coretext: EngineRules;
+  readonly directwrite: EngineRules;
+};
+/** The name of a text engine of the table `engines`. */
+type EngineName = keyof typeof engines;
+/** This function tells if a text is the name of an engine of the table `engines`. */
+declare function isEngineName(name: string): name is EngineName;
+export { isEngineName as i, EngineRules as n, engines as r, EngineName as t };
+//# sourceMappingURL=engines.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engines.d.ts","names":[],"sources":["../../src/fonts/engines.ts"],"mappings":";;;;UAIiB;;WAEN;;WAEA;;WAEA;;;;;WAKA;;;;;;cAOE;WAAoB,UAAU;WAAsB,UAAU;WAAsB,aAAa;;;KAUlG,0BAA0B;;iBAGtB,aAAa,eAAe,QAAQ"}

package/build/chunks/engines.js

@@ -0,0 +1,35 @@
+// src/fonts/engines.ts
+/**
+* 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.
+*/
+const engines = {
+	/** 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"
+	}
+};
+/** This function tells if a text is the name of an engine of the table `engines`. */
+function isEngineName(name) {
+	return Object.hasOwn(engines, name);
+}
+export { isEngineName as n, engines as t };
+
+//# sourceMappingURL=engines.js.map

package/build/chunks/engines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engines.js","names":[],"sources":["../../src/fonts/engines.ts"],"sourcesContent":["/**\n * The rules of one text engine for the widths of a font. The fields `deltas` and `metrics` are options of `readFont`, and\n * the fields `rounding` and `sum` are options of `measureWidth`. Thus a caller spreads the same row into the two calls.\n */\nexport interface EngineRules {\n  /** The rounding of the `HVAR` and `gvar` deltas of an instance. */\n  readonly deltas: \"round\" | \"exact\";\n  /** The advance of a composite glyph: its own advance, or the advance of its component with the flag USE_MY_METRICS. */\n  readonly metrics: \"own\" | \"component\";\n  /** The rounding of each advance: `pixel` rounds it to whole px, and `exact` keeps the fraction. */\n  readonly rounding: \"exact\" | \"pixel\";\n  /**\n   * The sum of the advances: `exact`, or `float32` as Blink adds the widths of the words of a canvas in single precision.\n   * A sum of whole px is exact in single precision, so the rounding `pixel` needs no `float32` sum.\n   */\n  readonly sum: \"exact\" | \"float32\";\n}\n\n/**\n * The rules of the text engines of Chromium, one row for each engine. The fonts runs of typeset#27 measured each row\n * against the canvas, and the T1d diagnosis of the sum measured the field `sum`. A new engine is a new row.\n */\nexport const engines: { readonly freetype: EngineRules; readonly coretext: EngineRules; readonly directwrite: EngineRules } = {\n  /** FreeType, as Chromium on Linux uses it: rounded deltas, and each advance in whole px. */\n  freetype: { deltas: \"round\", metrics: \"own\", rounding: \"pixel\", sum: \"exact\" },\n  /** CoreText on macOS: it keeps the fraction of the deltas. */\n  coretext: { deltas: \"exact\", metrics: \"own\", rounding: \"exact\", sum: \"float32\" },\n  /** DirectWrite on Windows: a composite glyph has the advance of its USE_MY_METRICS component. */\n  directwrite: { deltas: \"round\", metrics: \"component\", rounding: \"exact\", sum: \"float32\" },\n};\n\n/** The name of a text engine of the table `engines`. */\nexport type EngineName = keyof typeof engines;\n\n/** This function tells if a text is the name of an engine of the table `engines`. */\nexport function isEngineName(name: string): name is EngineName {\n  return Object.hasOwn(engines, name);\n}\n"],"mappings":";;;;;AAsBA,MAAa,UAAiH;;CAE5H,UAAU;EAAE,QAAQ;EAAS,SAAS;EAAO,UAAU;EAAS,KAAK;CAAQ;;CAE7E,UAAU;EAAE,QAAQ;EAAS,SAAS;EAAO,UAAU;EAAS,KAAK;CAAU;;CAE/E,aAAa;EAAE,QAAQ;EAAS,SAAS;EAAa,UAAU;EAAS,KAAK;CAAU;AAC1F;;AAMA,SAAgB,aAAa,MAAkC;CAC7D,OAAO,OAAO,OAAO,SAAS,IAAI;AACpC"}

package/build/chunks/font.d.ts

@@ -0,0 +1,203 @@
+import { t as Decompress } from "./sfnt.js";
+/**
+ * The GSUB features that the default model applies: the features that HarfBuzz and Chromium apply to horizontal text
+ * when the page does not change them.
+ */
+declare const defaultFeatures: readonly string[];
+/**
+ * The data that a syllabic shaper keeps with each glyph, as the `hb_glyph_info_t` of HarfBuzz keeps it. A substitution
+ * gives each new glyph a copy of the data of the glyph that it replaces. A ligature keeps the data of its first glyph.
+ */
+interface GlyphInfo {
+  /** The feature mask. A lookup starts only at a glyph with a bit of the mask of the lookup. */
+  mask: number;
+  /** The syllable byte of HarfBuzz: the serial number in the high 4 bits, and the syllable type in the low 4 bits. */
+  syllable: number;
+  /** The glyph properties `SUBSTITUTED`, `LIGATED` and `MULTIPLIED`. */
+  props: number;
+  /** The category of the shaper. */
+  category: number;
+  /** The position of the shaper. */
+  position: number;
+  /** The code point of the character of the glyph, after the normalization. */
+  readonly codePoint: number;
+}
+/** A lookup of GSUB for one script and one set of features. */
+interface SubstitutionLookup {
+  /** The index of the lookup in the lookup list of GSUB. */
+  readonly index: number;
+  /** The lookup type, from 1 to 8. The type of an Extension lookup is the type of its subtables. */
+  readonly type: number;
+  /** The lookup flags. */
+  readonly flags: number;
+  /** The tags of the features that use the lookup. */
+  readonly features: readonly string[];
+  /**
+   * This function applies the lookup to all the glyphs of a text. It changes the array. The array `masks`, when it is
+   * given, has one mask for each glyph. Then the lookup starts only at a glyph whose mask has a bit of `mask`, as the
+   * feature masks of HarfBuzz do. The function keeps `masks` in step with the glyphs.
+   */
+  apply(glyphs: number[], masks?: number[], mask?: number): void;
+  /**
+   * This function applies the lookup with the data `infos` of the glyphs, as HarfBuzz applies a lookup of a syllabic shaper.
+   * The lookup starts at a glyph with a bit of `mask`, and each input glyph after it also needs a bit of `mask`. When
+   * `perSyllable` is true, all the matched glyphs have the syllable of the first glyph. The function keeps `infos` in step.
+   */
+  applyInfos(glyphs: number[], infos: GlyphInfo[], mask: number, perSyllable: boolean): void;
+  /**
+   * This function tells if the lookup changes the glyph sequence `glyphs` when the sequence is all the text, as
+   * `hb_ot_layout_lookup_would_substitute` with zero context tells it. A context rule with backtrack or lookahead does not apply.
+   */
+  wouldApply(glyphs: readonly number[]): boolean;
+}
+/** One axis of `fvar`, in the user units of the axis. */
+interface Axis {
+  readonly tag: string;
+  readonly min: number;
+  readonly default: number;
+  readonly max: number;
+}
+/** The coordinates of an instance in user units, by axis tag. An axis that is absent has its default value. */
+type Instance = Readonly<Record<string, number>>;
+/** The change of the advances of two glyphs, in font units. A variable font can give a value that is not a whole number. */
+interface PairValue {
+  readonly first: number;
+  readonly second: number;
+  /** The part of `first` that comes from a VariationIndex table. HarfBuzz scales this part and the rest in different ways. */
+  readonly firstDelta?: number;
+  /** The part of `second` that comes from a VariationIndex table. */
+  readonly secondDelta?: number;
+  /** It is true when the subtable has a value for the second glyph. Then the next pair starts after the second glyph. */
+  readonly skipSecond: boolean;
+}
+/** A lookup of pair adjustments, with the flags that tell which glyphs it skips. */
+interface PairLookup {
+  readonly flags: number;
+  /**
+   * This function tells if the lookup skips a glyph, when the lookup uses a mark filtering set. Then the lookup skips each
+   * mark that is not in the set. Without the function, the flags alone tell which glyphs the lookup skips.
+   */
+  readonly skip?: (glyph: number) => boolean;
+  /** This function gives the value for a pair, or `undefined` when no subtable applies. */
+  pair(first: number, second: number): PairValue | undefined;
+}
+/** The options of `readFont`. */
+interface ReadOptions {
+  /** The Brotli decompress function. A WOFF2 file needs it. */
+  readonly decompress?: Decompress;
+  /**
+   * The instance of a variable font, in the user units of its axes, for example `{ wght: 400 }`. An absent axis has its
+   * default value. A browser uses the CSS weight, so a page with the weight `normal` needs `{ wght: 400 }`.
+   */
+  readonly instance?: Instance;
+  /**
+   * The rounding of the `HVAR` deltas. `round` (the default) rounds each delta to whole font units, as FreeType does.
+   * `exact` keeps the fraction. The epoch tells the two modes apart.
+   */
+  readonly deltas?: "round" | "exact";
+  /**
+   * The source of the advances of an instance. `auto` (the default) uses `HVAR` when the font has it, else the phantom
+   * points of `gvar`. `gvar` uses the phantom points also when the font has `HVAR`. The epoch tells the two modes apart.
+   */
+  readonly advances?: "auto" | "gvar";
+  /**
+   * The advance of a composite glyph. `own` (the default) uses the advance of the glyph, as FreeType and CoreText do.
+   * `component` uses the advance of its component with the flag USE_MY_METRICS, as DirectWrite does.
+   */
+  readonly metrics?: "own" | "component";
+}
+/** The source of the advances of an instance: the default advances of `hmtx`, the deltas of `HVAR`, or the phantom points of `gvar`. */
+type AdvanceSource = "hmtx" | "HVAR" | "gvar";
+/** The measured tables of one font file. */
+interface Font {
+  /**
+   * The font epoch: the revision of `head` and an FNV-1a hash of the data that gives the widths. A cache of widths can use
+   * it as a key. The TrueType file and the WOFF2 file of one font give the same epoch.
+   */
+  readonly epoch: string;
+  readonly unitsPerEm: number;
+  /** The axes of `fvar`. A font that is not variable has no axes. */
+  readonly axes: readonly Axis[];
+  /** The instance of the font: the value of each axis in user units, after the clamp to the range of the axis. */
+  readonly instance: Instance;
+  /** The normalized coordinates of the instance, one for each axis, after `avar`. */
+  readonly coordinates: readonly number[];
+  /** The source of the advances of this instance. The default instance and a font that is not variable use `hmtx`. */
+  readonly advanceSource: AdvanceSource;
+  readonly numGlyphs: number;
+  /** This function gives the glyph of a code point, or 0 when the font has no glyph for it. */
+  glyph(codePoint: number): number;
+  /** This function gives the advance of a glyph in font units, as the shaper uses it. A mark has the advance 0. */
+  advance(glyph: number): number;
+  /** This function gives the GDEF class of a glyph: 1 base, 2 ligature, 3 mark, 4 component, 0 none. */
+  glyphClass(glyph: number): number;
+  /** This function gives the pair lookups of the kerning for an OpenType script tag, for example `latn`. */
+  kerning(script: string): readonly PairLookup[];
+  /** This function gives the GSUB lookups of a list of feature tags for an OpenType script tag, in the order of the lookup list. */
+  substitutions(script: string, features: readonly string[]): readonly SubstitutionLookup[];
+  /** This function gives the same font at another instance. It uses the tables that are already read. */
+  at(instance: Instance): Font;
+}
+/** This function reads a TrueType, OpenType or WOFF2 file. */
+declare function readFont(bytes: Uint8Array, options?: ReadOptions): Font;
+/** The options of `measureWidth`. */
+interface MeasureOptions {
+  /** The OpenType script tag of the text, for example `latn` or `cyrl`. The default is `DFLT`. */
+  readonly script?: string;
+  /**
+   * The rounding of the width. `exact` (the default) adds the advances with no rounding. `pixel` rounds each advance to
+   * 1/64 px and then to a whole px, and each kerning value to a whole px. Chromium on Linux does this at the device scale 1.
+   */
+  readonly rounding?: "exact" | "pixel";
+  /** The pair kerning. When it is `false`, the width is the sum of the advances only. The default is `true`. */
+  readonly kerning?: boolean;
+  /**
+   * The GSUB features to apply before the kerning. The default is `defaultFeatures`: the features that a browser applies
+   * when the page does not change them. An empty list applies no feature of the list. The joining forms are not in the
+   * list. The option `joining` controls them.
+   */
+  readonly features?: readonly string[];
+  /**
+   * The joining of the Arabic shaper of HarfBuzz. When it is `true` (the default), the scripts of `joiningScripts` get the
+   * joining forms, for example `init` and `fina`. Their features then go in the stages of `joiningStages`. The other
+   * scripts do not change. When it is `false`, all the scripts use the one stage of the other scripts.
+   */
+  readonly joining?: boolean;
+  /**
+   * The Indic shaper of HarfBuzz. When it is `true` (the default), the scripts of `indicScripts` get the syllables, the
+   * reordering and the stages of `indicShaper`. When it is `false`, they use the one stage of the other scripts.
+   */
+  readonly indic?: boolean;
+  /**
+   * The shaping of the browser to model. `dom` (the default) shapes the words of `shapingWords` and then kerns all the
+   * text. `canvas` shapes and kerns each word of `canvasWords` alone, as Blink does for the text of a canvas.
+   */
+  readonly shaping?: "dom" | "canvas";
+  /**
+   * The sum of the advances. `exact` (the default) adds them with no rounding. `float32` models the canvas of Blink with
+   * CoreText and DirectWrite. Then the option `shaping` has no effect. The rounding `pixel` ignores this option.
+   */
+  readonly sum?: "exact" | "float32";
+}
+/**
+ * This function divides a text into the words that the GSUB pass shapes one at a time. Each space and each tab is a word
+ * alone. Blink shapes the text of a canvas in the same words, so no GSUB context goes across a space.
+ */
+declare function shapingWords(text: string): string[];
+/**
+ * This function gives the glyphs of a text and their advances in font units. With the shaping `dom`, it applies the GSUB
+ * substitutions to each word of `shapingWords`, and then the pair kerning to all the text. With the shaping `canvas`, it
+ * applies the substitutions and the kerning to each word of `canvasWords` alone. A script of `joiningScripts` also gets
+ * the joining forms of each word, in the stages of `joiningStages`. A script of `indicScripts` uses `indicShaper`.
+ */
+declare function glyphAdvances(font: Font, text: string, options?: MeasureOptions): {
+  glyphs: number[];
+  advances: number[];
+};
+/**
+ * This function gives the width of a text in px at the size `size` in px. The width is the sum of the advances after the
+ * GSUB substitutions and the pair kerning.
+ */
+declare function measureWidth(font: Font, text: string, size: number, options?: MeasureOptions): number;
+export { measureWidth as a, Axis as c, glyphAdvances as i, Instance as l, MeasureOptions as n, readFont as o, ReadOptions as r, shapingWords as s, Font as t, defaultFeatures as u };
+//# sourceMappingURL=font.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font.d.ts","names":[],"sources":["../../src/fonts/substitution.ts","../../src/fonts/variations.ts","../../src/fonts/kerning.ts","../../src/fonts/font.ts"],"mappings":";;;;;cAQa;;;;;UA6CI;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;WAES;;;UAIM;;WAEN;;WAEA;;WAEA;;WAEA;;;;;;EAMT,MAAM,kBAAkB,kBAAkB;;;;;;EAM1C,WAAW,kBAAkB,OAAO,aAAa,cAAc;;;;;EAK/D,WAAW;;;UC3FI;WACN;WACA;WACA;WACA;;;KAIC,WAAW,SAAS;;UCLf;WACN;WACA;;WAEA;;WAEA;;WAEA;;;UAIM;WACN;;;;;WAKA,QAAQ;;EAEjB,KAAK,eAAe,iBAAiB;;;UCbtB;;WAEN,aAAa;;;;;WAKb,WAAW;;;;;WAKX;;;;;WAKA;;;;;WAKA;;;KAIC;;UAGK;;;;;WAKN;WACA;;WAEA,eAAe;;WAEf,UAAU;;WAEV;;WAEA,eAAe;WACf;;EAET,MAAM;;EAEN,QAAQ;;EAER,WAAW;;EAEX,QAAQ,0BAA0B;;EAElC,cAAc,gBAAgB,uCAAuC;;EAErE,GAAG,UAAU,WAAW;;;iBAIV,SAAS,OAAO,YAAY,UAAS,cAAmB;;UA8JvD;;WAEN;;;;;WAKA;;WAEA;;;;;;WAMA;;;;;;WAMA;;;;;WAKA;;;;;WAKA;;;;;WAKA;;;;;;iBAYK,aAAa;;;;;;;iBAgDb,cAAc,MAAM,MAAM,cAAc,UAAS;EAAwB;EAAkB;;;;;;iBAkG3F,aAAa,MAAM,MAAM,cAAc,cAAc,UAAS"}