reamkit 1.29.0 → 1.31.0

package/README.md

@@ -27,10 +27,12 @@ Runtime dependencies are minimal: `fflate` (ZIP/Deflate) and `fast-xml-parser`.
 ## Usage
 
 Parse once into the format-neutral interlayer, convert to any target. The
-format (docx/xlsx) is sniffed from the bytes; no fonts to wire up — an open
+format is sniffed from the bytes; no fonts to wire up — an open
 metric-compatible substitute font (Arimo for sans, Tinos for serif, Cousine for
 monospace, plus Carlito/Caladea for Calibri/Cambria — the same families LibreOffice
-substitutes) is fetched automatically based on the document's referenced fonts:
+substitutes) is fetched automatically based on the document's referenced fonts,
+with a Noto face for the Japanese, Korean, Chinese, Arabic, Hebrew or Thai text
+the document holds:
 
 ```ts
 import { Ream } from 'reamkit';
@@ -38,7 +40,7 @@ import { Ream } from 'reamkit';
 // e.g. from an <input type="file"> or a fetch() — anything that yields bytes.
 const bytes = new Uint8Array(await file.arrayBuffer());
 
-const doc = Ream.parse(bytes);            // docx, xlsx, pptx or pdf — sniffed
+const doc = Ream.parse(bytes);            // docx, xlsx, pptx, pdf, doc, xls or ppt — sniffed
 const pdf = await doc.convert('pdf');     // async — fetches a font if needed
 const svg = await doc.convert('svg');     // same parse, different target
 const html = await doc.convert('html');   // flowed HTML — needs no fonts at all
@@ -57,6 +59,13 @@ and `doc.convertWithReport(...)` returns `{ bytes, losses }` (pass
 are plain `Uint8Array`s, so wiring this to files, the network, or disk is up
 to you.
 
+An encrypted source opens with its password — a PDF's user password, or an
+Office package's (MS-OFFCRYPTO, Agile and Standard):
+
+```ts
+const doc = Ream.parse(bytes, { password: 'secret' });
+```
+
 ### Bring your own fonts (no network)
 
 To embed specific fonts — or to avoid the network entirely — pass the font
@@ -139,7 +148,7 @@ rendering — inspect or analyze it without converting:
 
 ```ts
 const doc = Ream.parse(bytes);
-doc.format;     // 'docx' | 'xlsx' | 'pptx' | 'pdf'
+doc.format;     // 'docx' | 'xlsx' | 'pptx' | 'pdf' | 'doc' | 'xls' | 'ppt'
 doc.flow.body;  // paragraphs / tables / images / charts …
 doc.losses;     // read-time losses
 ```
@@ -157,7 +166,9 @@ const pdf = await doc.convert('pdf', { fonts, hyphenator });
 `convert` accepts (beyond the above): `info` (PDF `/Info` metadata — also read
 automatically from the document's `docProps/core.xml`), `attachments`
 (PDF/A-3 associated files), `tagged` (logical structure without full PDF/A),
-`pageWidth`/`pageHeight`/margins overrides.
+`encrypt` (AES-256 with a user and an owner password and the permissions a
+reader keeps: printing, copying, modifying, …), `pageWidth`/`pageHeight`/margins
+overrides.
 
 ### Lower-level APIs
 
@@ -166,6 +177,9 @@ automatically from the document's `docProps/core.xml`), `attachments`
   keeping unused formats out of your bundle); `layoutStyledDocument` produces the
   frozen page model (`PageItem` pages in a top-left `Pt` frame) the page-based
   writers consume (`docxWriter` works from the flow model, before layout).
+- `createConverter({ readers })` — a converter over a reader registry of your
+  own: `detect` names the reader that recognises the bytes, and `convert` reads
+  and converts them in one call, returning `{ bytes, losses }`.
 - `renderStyledPdf` drives the layout engine directly; the typed document
   model is on the `reamkit/document-model` subpath.
 
@@ -187,27 +201,49 @@ encryption, digital signatures (PKCS#7/ECDSA/PAdES/RFC 3161), SVG page
 preview, flowed HTML export, and **docx + xlsx output** (write WordprocessingML
 / SpreadsheetML back out, incl. round-trips). Reads OOXML Transitional and Strict.
 
+A Word document is laid out by Word's own rules, each measured in Word: a line
+as tall as Word sets its faces, two paragraphs standing the larger of their
+spacings apart rather than the sum, widow and orphan control, a heading kept with
+what it heads, table borders that take the room they are wide, a Word 2010
+table placed by its first cell's text, and sections whose lines run down the
+sheet.
+
 **Reads PDF, too.** `Ream.parse` accepts a PDF and reconstructs a `FlowDoc` — a
 tagged PDF from its structure tree (headings, tables, lists, reading order), an
-untagged one heuristically from glyph positions (lines, paragraphs, headings,
-and a clean two-column split). It lifts back the text (via each font's
-`/ToUnicode`, or the embedded program's own `cmap` where there is none, or the
-glyph names its `/Encoding` states — which is all a PDF from TeX gives), the
-font programs themselves, raster images (JPEG verbatim; PNG/Flate/LZW/CCITT-fax
-and **JBIG2** decoded and re-encoded), `/Link` hyperlinks, form-XObject content,
-annotation appearances (drawing one itself where the file supplies none),
-colour set through a named space — device, CIE (`CalGray`, `Lab`) or a
-`Separation`/`DeviceN` run through its own tint transform — and the page's
-artwork: filled / stroked / gradient shapes, clipping paths, tiling patterns,
-stencil image masks, constant alpha, and the Type 3 glyphs that are drawings
-rather than letters. It honours the layers a file turns off (§8.11 optional
-content) and the box it says to show (`/CropBox`), and it decides for itself
-whether a file is a document to re-flow or a page to keep — a paper is mostly
-lines, a form is mostly marks — and there is nothing to configure: a caller
-cannot know which of the two it was handed. It reads modern compressed files (cross-reference
-+ object streams) and encrypted ones (RC4 / AES — the user password is passed to
-`Ream.parse(bytes, { password })`, defaulting to the permissions-only case); a
-filter it does not carry can be handed to it through
+untagged one from where its glyphs stand: lines and paragraphs at the page's own
+pitch, with their indents and alignment; headings and list items; columns of
+any number, breaking and balancing where the page does; tables ruled or set out
+on stops, within a column or across them; code listings; figures, a drawing and
+the labels set on it kept as one group; the hanging entries of an index; and a
+heading's bar as its shading. Running heads and feet become headers and footers,
+their numbers PAGE fields counted in the page's own numerals — a book's roman
+front matter, and a foot of its own for each side of its spreads.
+
+It lifts back the text (via each font's `/ToUnicode`, or the embedded program's
+own `cmap` where there is none, or the glyph names its `/Encoding` states — which
+is all a PDF from TeX gives, its Greek and mathematics included) and the font
+programs themselves: written to `.docx`, each face the page drew with travels
+with the document, rebuilt as TrueType with the page's own advances, kerning and
+ligatures, and embedded where its licence (OS/2 `fsType`) allows — so a line
+breaks where the page broke it, on a machine that has none of its fonts. Raster
+images come back (JPEG verbatim, a CMYK one re-coloured; PNG/Flate/LZW/CCITT-fax
+and **JBIG2** decoded and re-encoded), with `/Link` hyperlinks, form-XObject
+content, annotation and form appearances (drawing one itself where the file
+supplies none), colour set through a named space — device, CIE (`CalGray`,
+`CalRGB`, `Lab`), ICC-based, or a `Separation`/`DeviceN` run through its own
+tint transform — and the page's artwork: filled / stroked / gradient shapes,
+dashes and caps, clipping paths, tiling patterns, stencil image masks, opacity,
+and the Type 3 glyphs that are drawings rather than letters.
+
+It honours the layers a file turns off (§8.11 optional content), the box it says
+to show (`/CropBox`) and the way it turns a page (`/Rotate` — a page whose words
+run down its sheet comes back as a section set that way), and it decides for
+itself whether a file is a document to re-flow or a page to keep — a paper is
+mostly lines, a form is mostly marks — and there is nothing to configure: a
+caller cannot know which of the two it was handed. It reads modern compressed
+files (cross-reference + object streams) and encrypted ones (RC4 / AES — the
+user password is passed to `Ream.parse(bytes, { password })`, defaulting to the
+permissions-only case); a filter it does not carry can be handed to it through
 `Ream.parse(bytes, { filters })`.
 
 A form or a drawing is not a reflowable document, so the reader keeps it as a

package/dist/esm/core/converter/project.js

@@ -28,7 +28,9 @@ function flowRenderOptions(flow) {
 		...flow.doNotExpandShiftReturn ? { doNotExpandShiftReturn: true } : {},
 		...flow.pageBackgroundColorHex ? { pageBackgroundColorHex: flow.pageBackgroundColorHex } : {},
 		...flow.pageBackgroundFill ? { pageBackgroundFill: flow.pageBackgroundFill } : {},
-		...flow.gutterAtTop ? { gutterAtTop: true } : {}
+		...flow.gutterAtTop ? { gutterAtTop: true } : {},
+		...flow.typesetBy ? { typesetBy: flow.typesetBy } : {},
+		...flow.compatibilityMode !== void 0 ? { compatibilityMode: flow.compatibilityMode } : {}
 	};
 }
 //#endregion

package/dist/esm/core/crypto/offcrypto.js

@@ -1,5 +1,5 @@
-import { openCfb } from "../ole/cfb.js";
 import { aesCbcDecrypt, aesEcbDecrypt, sha1, sha256, sha384, sha512 } from "./primitives.js";
+import { openCfb } from "../ole/cfb.js";
 //#region src/core/crypto/offcrypto.ts
 /** Thrown when the bytes are encrypted and the password does not open them. */
 var WrongPasswordError = class extends Error {

package/dist/esm/core/document-model/index.d.ts

@@ -5,4 +5,4 @@
  *
  * @packageDocumentation
  */
-export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, Comment, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, CellDataBar, CellIcon, CellIconShape, CellSparkline, Chart, ChartBlock, ChartDataPoint, ChartLineStyle, ChartMarker, ChartMarkerSymbol, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, ImageCrop, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, PictureBullet, PictureOutline, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, FrameProperties, RelativeSize, TabStop, Run, RunProperties, TextOutline, RowConditionalFormat, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeShadow, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeGroupChild, ShapeLine, LineEnd, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';
+export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, Comment, CellBorders, CellMerge, DocumentInfo, CellMargins, CellProperties, CellShading, CellDataBar, CellIcon, CellIconShape, CellSparkline, Chart, ChartBlock, ChartDataPoint, ChartLineStyle, ChartMarker, ChartMarkerSymbol, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, ImageCrop, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, PictureBullet, PictureOutline, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, FrameProperties, RelativeSize, TabStop, Run, RunProperties, TextOutline, Ligatures, RowConditionalFormat, RowProperties, Section, FloatAnchor, SectionColumns, SectionProperties, ShapeBlock, ShapeShadow, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeGroupChild, ShapeLine, LineEnd, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableLook, TableProperties, TableStyleCondition, TableStyleConditionType, TableStyleLayer, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';

package/dist/esm/core/document-model/types.d.ts

@@ -6,6 +6,12 @@ export type Alignment = 'left' | 'right' | 'center' | 'both' | 'distribute';
 export type UnderlineStyle = 'none' | 'single' | 'double' | 'thick' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'wave';
 /** Run vertical alignment (`w:vertAlign`): baseline or super/subscript. */
 export type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
+/**
+ * [MS-DOCX] ST_Ligatures — which of a face's OpenType ligatures a run is set
+ * with (`w14:ligatures`): the standard ones (`liga`), the contextual (`clig`),
+ * the historical (`hlig`) and the discretionary (`dlig`), alone or together.
+ */
+export type Ligatures = 'none' | 'standard' | 'contextual' | 'historical' | 'discretional' | 'standardContextual' | 'standardHistorical' | 'contextualHistorical' | 'standardDiscretional' | 'contextualDiscretional' | 'historicalDiscretional' | 'standardContextualHistorical' | 'standardContextualDiscretional' | 'standardHistoricalDiscretional' | 'contextualHistoricalDiscretional' | 'all';
 /**
  * The four script slots of `w:rFonts` (§17.3.2.26). A character picks its font
  * from the slot its Unicode range maps to (ASCII, high-ANSI, complex-script,
@@ -63,6 +69,21 @@ export interface RunProperties {
      * (negative tightens). Word states it in twentieths of a point.
      */
     readonly letterSpacingPt?: Pt;
+    /**
+     * §17.3.2.43 `w:w` — each character set at this share of its own width
+     * (1 is as the face sets it), the glyph itself narrowed or widened.
+     */
+    readonly widthScale?: number;
+    /**
+     * §17.3.2.19 `w:kern` — the run's glyph pairs are KERNED, at this size and
+     * above (0 turns kerning off). Word kerns nothing a run does not ask for.
+     */
+    readonly kerningMinPt?: Pt;
+    /**
+     * [MS-DOCX] `w14:ligatures` — the face's ligatures the run is set with.
+     * Word forms none at all in a document it opens in compatibility mode.
+     */
+    readonly ligatures?: Ligatures;
     /**
      * §21.1.2.3.9 `a:rPr/a:ln` — a line drawn round the glyphs themselves, which
      * DrawingML puts on a run and ISO 32000-1 §9.3.6 calls a text rendering mode
@@ -220,6 +241,24 @@ export interface ParagraphProperties {
      * starts on a fresh page even if there is room on the current one.
      */
     readonly pageBreakBefore?: boolean;
+    /**
+     * ECMA-376 Part 1 §17.3.1.14 — `w:keepNext`. The paragraph stands on the
+     * same page as the start of the one after it: a heading is not left at the
+     * foot of a page with its text on the next.
+     */
+    readonly keepNext?: boolean;
+    /**
+     * ECMA-376 Part 1 §17.3.1.15 — `w:keepLines`. The paragraph's lines stand on
+     * one page, wherever one page holds them all.
+     */
+    readonly keepLines?: boolean;
+    /**
+     * ECMA-376 Part 1 §17.3.1.44 — `w:widowControl`. When on, a page or column
+     * break that would leave the paragraph's first line alone at the foot of one
+     * page, or its last line alone at the head of the next, is moved so that
+     * neither stands alone. Word applies it wherever nothing says otherwise.
+     */
+    readonly widowControl?: boolean;
     /**
      * ECMA-376 §17.3.1.6 — `w:bidi`. Sets the paragraph's base direction to RTL,
      * so the BiDi paragraph embedding level is 1 and default alignment is right.
@@ -1127,6 +1166,8 @@ export interface ShapeLine {
     readonly customDash?: ReadonlyArray<number>;
     readonly cap?: 'flat' | 'round' | 'square';
     readonly fill?: 'solid' | 'none';
+    /** §20.1.2.3.1 `a:alpha` on the line's colour — how opaque the stroke is, `0..1`. */
+    readonly alpha?: number;
     /** §20.1.8.24 `a:headEnd` — the decoration at the line's first point. */
     readonly headEnd?: LineEnd;
     /** §20.1.8.42 `a:tailEnd` — the decoration at the line's last point. */
@@ -1174,6 +1215,13 @@ export interface ShapeTextBody {
     readonly insetRight?: Pt;
     readonly insetBottom?: Pt;
     readonly anchor?: 't' | 'ctr' | 'b';
+    /**
+     * §20.1.2.1.1 `a:bodyPr @wrap="none"` — the lines run as far as their words
+     * do, whatever the box's width. A label placed where a page set it is sized
+     * to the words it was measured from, and set in a face a little wider it
+     * broke inside its one word.
+     */
+    readonly noWrap?: boolean;
     /**
      * §20.1.10.83 ST_TextVerticalType (`a:bodyPr @vert`) — text set along the
      * box's long axis rather than across it. `vert` reads top-to-bottom (turned a
@@ -1541,6 +1589,12 @@ export interface SectionProperties {
      * printed with. Absent ⇒ the count carries on from the section before.
      */
     readonly pageNumberStart?: number;
+    /**
+     * §17.6.12 `w:pgNumType w:fmt` — how a PAGE field prints the section's page
+     * numbers (§17.18.59): `lowerRoman` numbers a book's front matter i, ii,
+     * iii before its body starts again at 1. Absent ⇒ decimal.
+     */
+    readonly pageNumberFormat?: NumberingFormat;
     /** §17.6.8 `w:lnNumType` — line numbers printed in the margin beside the text. */
     readonly lineNumbering?: {
         /** Print every `countBy`-th line (default 1). */
@@ -1577,6 +1631,17 @@ export interface SectionProperties {
      * distinguished from `nextPage`.)
      */
     readonly sectionStart?: 'continuous' | 'nextPage' | 'oddPage' | 'evenPage';
+    /**
+     * §17.6.20 `w:textDirection` — which way the section's lines run. `tbRl`
+     * sets each line top to bottom and the next one to the left of it: the
+     * text turned a quarter clockwise on the sheet, which is how a viewer shows
+     * a page turned by `/Rotate 90` whose words stood upright in its box. Word
+     * lays a section out that way for `btLr` as well, so the layout reads both
+     * alike. Only the body's text turns: the headers, the footers and every
+     * drawing anchored to the page keep the sheet's own axes. Absent ⇒ left to
+     * right, top to bottom.
+     */
+    readonly textDirection?: 'tbRl' | 'btLr';
     /**
      * §17.6.5 `w:docGrid` — the line grid a `lines`/`linesAndChars` section rules
      * its text onto, as the pitch in points. Every line of the section's text is

package/dist/esm/core/drawingml/shape-render.js

@@ -192,13 +192,25 @@ function buildStroke(line) {
 	const widthPt = line.width ?? DEFAULT_LINE_WIDTH_EMU / 12700;
 	const dash = line.customDash?.map((n) => Math.max(.01, n * widthPt)) ?? (line.dash && line.dash !== "solid" ? dashPattern(line.dash, widthPt) : void 0);
 	const cap = line.cap === "flat" ? "butt" : line.cap;
+	const colorHex = line.colorHex ?? "000000";
 	return {
-		colorHex: line.colorHex ?? "000000",
+		colorHex: line.alpha !== void 0 && line.alpha < 1 ? overWhite(colorHex, line.alpha) : colorHex,
 		widthPt,
 		...dash ? { dash } : {},
 		...cap ? { cap } : {}
 	};
 }
+/** A 6-hex colour drawn at `alpha` over white, as the opaque colour it comes to. */
+function overWhite(hex, alpha) {
+	const n = parseInt(hex, 16);
+	if (Number.isNaN(n)) return hex;
+	const a = Math.max(0, Math.min(1, alpha));
+	return [
+		16,
+		8,
+		0
+	].map((shift) => Math.round(255 - (255 - (n >> shift & 255)) * a).toString(16).padStart(2, "0")).join("").toUpperCase();
+}
 function dashPattern(dash, w) {
 	const u = Math.max(w, .1);
 	switch (dash) {

package/dist/esm/core/font/index.d.ts

@@ -9,3 +9,5 @@ export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';
 export { hasSubstitutable, lettersForLigature, substituteLetters } from './ligatures.js';
 export { createFontMeasure } from './measure.js';
 export type { FontMeasure } from './measure.js';
+export { buildTrueType, editableEmbedding, MAX_BUILT_GLYPHS } from './ttf-build.js';
+export type { BuiltFace, BuiltGlyph, BuiltKernPair, BuiltLigature, GlyphSeg, } from './ttf-build.js';

package/dist/esm/core/font/ttf-build.d.ts

@@ -0,0 +1,113 @@
+/** One piece of a glyph's outline, in a one-unit em with y up. */
+export type GlyphSeg = {
+    readonly op: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly op: 'close';
+};
+/** One glyph of a {@link BuiltFace}. */
+export interface BuiltGlyph {
+    /** The characters that select it, as code points. */
+    readonly codePoints: ReadonlyArray<number>;
+    /** Its contours, filled by the nonzero rule; empty for a blank glyph. */
+    readonly outline: ReadonlyArray<GlyphSeg>;
+    /** How far the pen moves after it, in thousandths of an em. */
+    readonly advance: number;
+}
+/** Everything {@link buildTrueType} needs to know about the face it builds. */
+export interface BuiltFace {
+    /** The family the font is installed under (`name` ID 1). */
+    readonly family: string;
+    /** The style within the family: its bold and italic slot (`name` ID 2). */
+    readonly bold: boolean;
+    readonly italic: boolean;
+    /** The PostScript name (`name` ID 6); only its printable ASCII is kept. */
+    readonly postScriptName: string;
+    readonly glyphs: ReadonlyArray<BuiltGlyph>;
+    /** Above and below the baseline, in thousandths of an em — `descent` negative. */
+    readonly ascent: number;
+    readonly descent: number;
+    readonly capHeight?: number;
+    readonly xHeight?: number;
+    /** Degrees counterclockwise from the vertical; a face slanted right is negative. */
+    readonly italicAngle?: number;
+    readonly fixedPitch?: boolean;
+    /**
+     * OS/2 `fsType` — the embedding the face's licence allows, carried over from
+     * the program the outlines came from.
+     */
+    readonly fsType: number;
+    /** The pairs the face is kerned by: how far the second glyph moves in towards the first. */
+    readonly kerning?: ReadonlyArray<BuiltKernPair>;
+    /** The glyphs the face draws for a run of characters at once: its ligatures. */
+    readonly ligatures?: ReadonlyArray<BuiltLigature>;
+}
+/**
+ * One ligature of a {@link BuiltFace}: a glyph no character reaches alone,
+ * substituted for the characters it joins wherever they meet (GSUB `liga`).
+ */
+export interface BuiltLigature {
+    /** The characters it stands for, in order — two or more. */
+    readonly codePoints: ReadonlyArray<number>;
+    readonly outline: ReadonlyArray<GlyphSeg>;
+    /** How far the pen moves after it, in thousandths of an em. */
+    readonly advance: number;
+}
+/** One kerning pair of a {@link BuiltFace}, by the characters it joins. */
+export interface BuiltKernPair {
+    /** The code point of the glyph on the left, and of the one after it. */
+    readonly left: number;
+    readonly right: number;
+    /** The adjustment to the left glyph's advance, in thousandths of an em — negative tightens. */
+    readonly value: number;
+}
+/**
+ * Whether a face's licence lets it be embedded, as outlines and subset, in a
+ * document that stays EDITABLE: OS/2 `fsType` states installable embedding (no
+ * usage bit) or grants editable embedding, and neither forbids subsetting nor
+ * allows bitmaps only. Restricted-licence and preview-and-print faces are
+ * refused — the second may travel only in a document opened read-only.
+ *
+ * Several usage bits at once is an old font's way of stating permissions, and
+ * the least restrictive of them applies (OS/2 versions 0–2).
+ *
+ * @param fsType The field, or `undefined` where the program states none —
+ *               which restricts nothing.
+ * @returns Whether an editable document may carry the face.
+ */
+export declare function editableEmbedding(fsType: number | undefined): boolean;
+/**
+ * The most glyphs a built face holds. A `cmap` format 4 subtable is limited to
+ * 64 KB, and past this many characters it may not fit; a face that large is a
+ * whole CJK font, which is no subset.
+ */
+export declare const MAX_BUILT_GLYPHS = 8000;
+/**
+ * Build a TrueType font from outlines (ISO/IEC 14496-22): `.notdef` first, then
+ * one glyph per {@link BuiltGlyph} in the order given, reachable through a
+ * Unicode `cmap`.
+ *
+ * Cubic curves become quadratic ones. A cubic that is a raised quadratic — what
+ * a TrueType source's outline arrives as — comes back as exactly that
+ * quadratic; any other is cut into as many quadratics as keep within half a
+ * unit of it. Each glyph's contours are turned to run clockwise round their
+ * ink, as TrueType's are.
+ *
+ * @param face The face: its names, metrics, licence and glyphs.
+ * @returns The font program's bytes.
+ * @throws When the face holds more than {@link MAX_BUILT_GLYPHS} glyphs.
+ */
+export declare function buildTrueType(face: BuiltFace): Uint8Array;