reamkit 0.1.0-alpha.0

package/dist/esm/crypto/cms.js

@@ -0,0 +1,34 @@
+import { certIssuerAndSerial, cmsTime, concat, explicit, integer, nullValue, octetString, oid, seq, set, setOfBody, tlv } from "./asn1.js";
+//#region src/crypto/cms.ts
+var OID = {
+	sha256: "2.16.840.1.101.3.4.2.1",
+	rsaEncryption: "1.2.840.113549.1.1.1",
+	ecdsaWithSHA256: "1.2.840.10045.4.3.2",
+	idData: "1.2.840.113549.1.7.1",
+	idSignedData: "1.2.840.113549.1.7.2",
+	contentType: "1.2.840.113549.1.9.3",
+	messageDigest: "1.2.840.113549.1.9.4",
+	signingTime: "1.2.840.113549.1.9.5"
+};
+var sha256AlgId = () => seq(oid(OID.sha256));
+var rsaAlgId = () => seq(oid(OID.rsaEncryption), nullValue());
+var ecdsaAlgId = () => seq(oid(OID.ecdsaWithSHA256));
+var attribute = (oidStr, value) => seq(oid(oidStr), set(value));
+async function buildPkcs7Detached(params) {
+	const { issuer, serial } = certIssuerAndSerial(params.certificate);
+	const attrsBody = setOfBody([
+		attribute(OID.contentType, oid(OID.idData)),
+		attribute(OID.messageDigest, octetString(params.messageDigest)),
+		attribute(OID.signingTime, cmsTime(params.signingTime))
+	]);
+	const signedAttrsForSigning = tlv(49, attrsBody);
+	const signedAttrsTagged = tlv(160, attrsBody);
+	const signature = await params.sign(signedAttrsForSigning);
+	const sigAlgId = params.signatureAlgorithm === "ecdsa" ? ecdsaAlgId() : rsaAlgId();
+	const signerInfo = seq(integer(1), seq(issuer, serial), sha256AlgId(), signedAttrsTagged, sigAlgId, octetString(signature));
+	const certificates = tlv(160, concat([params.certificate, ...params.extraCertificates ?? []]));
+	const signedData = seq(integer(1), set(sha256AlgId()), seq(oid(OID.idData)), certificates, set(signerInfo));
+	return seq(oid(OID.idSignedData), explicit(0, signedData));
+}
+//#endregion
+export { buildPkcs7Detached };

package/dist/esm/crypto/index.d.ts

@@ -0,0 +1,2 @@
+export { buildPkcs7Detached } from './cms.js';
+export type { CmsParams } from './cms.js';

package/dist/esm/crypto/index.js

@@ -0,0 +1 @@
+import "./cms.js";

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

@@ -0,0 +1 @@
+export type { AbstractNumbering, Alignment, Border, BorderStyle, BodyElement, CellBorders, CellMargins, CellProperties, CellShading, Chart, ChartBlock, ChartDataPoint, ChartSeries, ChartType, CustomGeometry, CustomPathCmd, DocumentModel, FontFamilyMap, HeaderFooterReference, HeaderFooterType, ImageBlock, InlineImage, MathAccent, MathBar, MathDelimiter, MathEqArray, MathFraction, MathFunc, MathGroupChr, MathLimit, MathMatrix, MathNary, MathNode, MathRadical, MathRow, MathRun, MathScript, Numbering, NumberingFormat, NumberingInstance, NumberingLevel, NumberingReference, PageMargins, PageSize, Paragraph, ParagraphProperties, Run, RunProperties, RowProperties, Section, SectionProperties, ShapeBlock, ShapeDash, ShapeFill, ShapeFillKind, ShapeGeometry, ShapeLine, ShapeTextBody, ShapeTransform, Style, StyleSheet, StyleType, Table, TableCell, TableProperties, TableRow, UnderlineStyle, VerticalAlign, } from './types.js';

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

@@ -0,0 +1,403 @@
+export type Alignment = 'left' | 'right' | 'center' | 'both' | 'distribute';
+export type UnderlineStyle = 'none' | 'single' | 'double' | 'thick' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'wave';
+export type VerticalAlign = 'baseline' | 'superscript' | 'subscript';
+export interface FontFamilyMap {
+    readonly ascii?: string;
+    readonly hAnsi?: string;
+    readonly cs?: string;
+    readonly eastAsia?: string;
+}
+export interface RunProperties {
+    readonly styleId?: string;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly underline?: UnderlineStyle;
+    readonly strike?: boolean;
+    readonly fontSizeHalfPoints?: number;
+    readonly colorHex?: string;
+    readonly fontFamily?: FontFamilyMap;
+    readonly verticalAlign?: VerticalAlign;
+    readonly rtl?: boolean;
+    readonly lang?: string;
+}
+export interface ParagraphProperties {
+    readonly styleId?: string;
+    readonly alignment?: Alignment;
+    readonly spacingBeforeTwips?: number;
+    readonly spacingAfterTwips?: number;
+    readonly spacingLineTwips?: number;
+    readonly spacingLineRule?: 'auto' | 'exact' | 'atLeast';
+    readonly indentLeftTwips?: number;
+    readonly indentRightTwips?: number;
+    readonly indentFirstLineTwips?: number;
+    readonly runProperties?: RunProperties;
+    readonly numbering?: NumberingReference;
+    readonly pageBreakBefore?: boolean;
+    readonly bidi?: boolean;
+    readonly outlineLevel?: number;
+}
+export interface InlineImage {
+    readonly imageId: string;
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+}
+export type MathNode = MathRow | MathRun | MathFraction | MathScript | MathRadical | MathNary | MathFunc | MathLimit | MathDelimiter | MathMatrix | MathAccent | MathBar | MathGroupChr | MathEqArray;
+export interface MathRow {
+    readonly type: 'row';
+    readonly children: ReadonlyArray<MathNode>;
+}
+export interface MathRun {
+    readonly type: 'run';
+    readonly text: string;
+    readonly italic?: boolean;
+    readonly bold?: boolean;
+    readonly nor?: boolean;
+}
+export interface MathFraction {
+    readonly type: 'fraction';
+    readonly num: MathNode;
+    readonly den: MathNode;
+    readonly barless?: boolean;
+}
+export interface MathScript {
+    readonly type: 'script';
+    readonly base: MathNode;
+    readonly sub?: MathNode;
+    readonly sup?: MathNode;
+    readonly pre?: boolean;
+}
+export interface MathRadical {
+    readonly type: 'radical';
+    readonly radicand: MathNode;
+    readonly degree?: MathNode;
+}
+export interface MathNary {
+    readonly type: 'nary';
+    readonly op: string;
+    readonly body: MathNode;
+    readonly sub?: MathNode;
+    readonly sup?: MathNode;
+    readonly limLoc?: 'undOvr' | 'subSup';
+}
+export interface MathFunc {
+    readonly type: 'func';
+    readonly name: MathNode;
+    readonly body: MathNode;
+}
+export interface MathLimit {
+    readonly type: 'limit';
+    readonly base: MathNode;
+    readonly lim: MathNode;
+    readonly pos: 'low' | 'upp';
+}
+export interface MathDelimiter {
+    readonly type: 'delimiter';
+    readonly begChr: string;
+    readonly endChr: string;
+    readonly sepChr?: string;
+    readonly children: ReadonlyArray<MathNode>;
+}
+export interface MathMatrix {
+    readonly type: 'matrix';
+    readonly rows: ReadonlyArray<ReadonlyArray<MathNode>>;
+}
+export interface MathAccent {
+    readonly type: 'accent';
+    readonly char: string;
+    readonly base: MathNode;
+}
+export interface MathBar {
+    readonly type: 'bar';
+    readonly base: MathNode;
+    readonly pos: 'top' | 'bot';
+}
+export interface MathGroupChr {
+    readonly type: 'groupChr';
+    readonly char: string;
+    readonly base: MathNode;
+    readonly pos: 'top' | 'bot';
+}
+export interface MathEqArray {
+    readonly type: 'eqArr';
+    readonly rows: ReadonlyArray<MathNode>;
+}
+export interface Run {
+    readonly text: string;
+    readonly properties: RunProperties;
+    readonly inlineImage?: InlineImage;
+    readonly math?: MathNode;
+    readonly pageBreak?: boolean;
+}
+export interface Paragraph {
+    readonly properties: ParagraphProperties;
+    readonly runs: ReadonlyArray<Run>;
+}
+export type NumberingFormat = 'decimal' | 'lowerLetter' | 'upperLetter' | 'lowerRoman' | 'upperRoman' | 'bullet' | 'none';
+export interface NumberingReference {
+    readonly numId: string;
+    readonly ilvl: number;
+}
+export interface NumberingLevel {
+    readonly ilvl: number;
+    readonly start: number;
+    readonly format: NumberingFormat;
+    readonly lvlText: string;
+    readonly paragraphProperties: ParagraphProperties;
+    readonly runProperties: RunProperties;
+}
+export interface AbstractNumbering {
+    readonly id: string;
+    readonly levels: ReadonlyMap<number, NumberingLevel>;
+}
+export interface NumberingInstance {
+    readonly numId: string;
+    readonly abstractNumId: string;
+}
+export interface Numbering {
+    readonly abstractNums: ReadonlyMap<string, AbstractNumbering>;
+    readonly numInstances: ReadonlyMap<string, NumberingInstance>;
+}
+export type StyleType = 'paragraph' | 'character' | 'table' | 'numbering';
+export interface Style {
+    readonly id: string;
+    readonly type: StyleType;
+    readonly basedOn?: string;
+    readonly isDefault: boolean;
+    readonly runProperties: RunProperties;
+    readonly paragraphProperties: ParagraphProperties;
+}
+export interface StyleSheet {
+    readonly defaultRunProperties: RunProperties;
+    readonly defaultParagraphProperties: ParagraphProperties;
+    readonly styles: ReadonlyMap<string, Style>;
+}
+export type BorderStyle = 'none' | 'single' | 'double' | 'thick' | 'dotted' | 'dashed';
+export interface Border {
+    readonly style: BorderStyle;
+    readonly sizeEighthPt?: number;
+    readonly colorHex?: string;
+}
+export interface CellBorders {
+    readonly top?: Border;
+    readonly right?: Border;
+    readonly bottom?: Border;
+    readonly left?: Border;
+    readonly insideH?: Border;
+    readonly insideV?: Border;
+}
+export interface CellMargins {
+    readonly topTwips?: number;
+    readonly rightTwips?: number;
+    readonly bottomTwips?: number;
+    readonly leftTwips?: number;
+}
+export interface CellShading {
+    readonly colorHex: string;
+}
+export interface CellProperties {
+    readonly widthTwips?: number;
+    readonly gridSpan?: number;
+    readonly vMerge?: 'restart' | 'continue';
+    readonly borders?: CellBorders;
+    readonly margins?: CellMargins;
+    readonly shading?: CellShading;
+}
+export interface RowProperties {
+    readonly heightTwips?: number;
+    readonly heightRule?: 'auto' | 'atLeast' | 'exact';
+    readonly cantSplit?: boolean;
+    readonly isHeader?: boolean;
+    readonly pageBreakBefore?: boolean;
+}
+export interface TableProperties {
+    readonly widthTwips?: number;
+    readonly widthType?: 'auto' | 'dxa' | 'pct' | 'nil';
+    readonly layout?: 'auto' | 'fixed';
+    readonly defaultCellMargins?: CellMargins;
+    readonly borders?: CellBorders;
+    readonly alignment?: 'left' | 'center' | 'right';
+}
+export interface TableCell {
+    readonly properties: CellProperties;
+    readonly content: ReadonlyArray<BodyElement>;
+}
+export interface TableRow {
+    readonly properties: RowProperties;
+    readonly cells: ReadonlyArray<TableCell>;
+}
+export interface Table {
+    readonly properties: TableProperties;
+    readonly grid: ReadonlyArray<number>;
+    readonly rows: ReadonlyArray<TableRow>;
+}
+export interface ImageBlock {
+    readonly imageId: string;
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly paragraphProperties: ParagraphProperties;
+    readonly altText?: string;
+}
+export type CustomPathCmd = {
+    readonly cmd: 'move';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly cmd: 'line';
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly cmd: 'cubic';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x2: number;
+    readonly y2: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly cmd: 'quad';
+    readonly x1: number;
+    readonly y1: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly cmd: 'arc';
+    readonly wR: number;
+    readonly hR: number;
+    readonly stAng: number;
+    readonly swAng: number;
+} | {
+    readonly cmd: 'close';
+};
+export interface CustomGeometry {
+    readonly pathWidth: number;
+    readonly pathHeight: number;
+    readonly commands: ReadonlyArray<CustomPathCmd>;
+}
+export interface ShapeGeometry {
+    readonly kind: 'preset' | 'custom';
+    readonly preset?: string;
+    readonly adjust?: ReadonlyMap<string, number>;
+    readonly custom?: CustomGeometry;
+}
+export type ShapeFillKind = 'none' | 'solid';
+export interface ShapeFill {
+    readonly kind: ShapeFillKind;
+    readonly colorHex?: string;
+}
+export type ShapeDash = 'solid' | 'dot' | 'dash' | 'dashDot' | 'lgDash' | 'lgDashDot' | 'sysDash' | 'sysDot';
+export interface ShapeLine {
+    readonly widthEmu?: number;
+    readonly colorHex?: string;
+    readonly dash?: ShapeDash;
+    readonly cap?: 'flat' | 'round' | 'square';
+    readonly fill?: 'solid' | 'none';
+}
+export interface ShapeTransform {
+    readonly rotation60k?: number;
+    readonly flipH?: boolean;
+    readonly flipV?: boolean;
+}
+export interface ShapeTextBody {
+    readonly content: ReadonlyArray<BodyElement>;
+    readonly insetLeftEmu?: number;
+    readonly insetTopEmu?: number;
+    readonly insetRightEmu?: number;
+    readonly insetBottomEmu?: number;
+    readonly anchor?: 't' | 'ctr' | 'b';
+}
+export interface ShapeBlock {
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly geometry: ShapeGeometry;
+    readonly fill: ShapeFill;
+    readonly line?: ShapeLine;
+    readonly transform?: ShapeTransform;
+    readonly text?: ShapeTextBody;
+    readonly paragraphProperties: ParagraphProperties;
+    readonly altText?: string;
+}
+export type ChartType = 'bar' | 'line' | 'pie' | 'area' | 'scatter' | 'unknown';
+export interface ChartDataPoint {
+    readonly idx: number;
+    readonly colorHex: string;
+}
+export interface ChartSeries {
+    readonly name?: string;
+    readonly values: ReadonlyArray<number>;
+    readonly xValues?: ReadonlyArray<number>;
+    readonly colorHex?: string;
+    readonly pointColors?: ReadonlyArray<ChartDataPoint>;
+}
+export interface Chart {
+    readonly type: ChartType;
+    readonly title?: string;
+    readonly categories: ReadonlyArray<string>;
+    readonly series: ReadonlyArray<ChartSeries>;
+    readonly hasLegend: boolean;
+    readonly legendPos?: 'r' | 'l' | 't' | 'b';
+    readonly barDir?: 'col' | 'bar';
+    readonly grouping?: 'clustered' | 'stacked' | 'percentStacked' | 'standard';
+    readonly doughnut?: boolean;
+    readonly showValues?: boolean;
+    readonly catAxisTitle?: string;
+    readonly valAxisTitle?: string;
+}
+export interface ChartBlock {
+    readonly chartRelId: string;
+    readonly widthEmu: number;
+    readonly heightEmu: number;
+    readonly paragraphProperties: ParagraphProperties;
+    readonly altText?: string;
+}
+export type BodyElement = {
+    readonly kind: 'paragraph';
+    readonly paragraph: Paragraph;
+} | {
+    readonly kind: 'table';
+    readonly table: Table;
+} | {
+    readonly kind: 'image';
+    readonly image: ImageBlock;
+} | {
+    readonly kind: 'shape';
+    readonly shape: ShapeBlock;
+} | {
+    readonly kind: 'chart';
+    readonly chart: ChartBlock;
+};
+export interface PageSize {
+    readonly widthTwips: number;
+    readonly heightTwips: number;
+    readonly orientation?: 'portrait' | 'landscape';
+}
+export interface PageMargins {
+    readonly topTwips: number;
+    readonly rightTwips: number;
+    readonly bottomTwips: number;
+    readonly leftTwips: number;
+    readonly headerTwips?: number;
+    readonly footerTwips?: number;
+}
+export type HeaderFooterType = 'default' | 'first' | 'even';
+export interface HeaderFooterReference {
+    readonly type: HeaderFooterType;
+    readonly relationshipId: string;
+}
+export interface SectionProperties {
+    readonly pageSize?: PageSize;
+    readonly margins?: PageMargins;
+    readonly headers: ReadonlyArray<HeaderFooterReference>;
+    readonly footers: ReadonlyArray<HeaderFooterReference>;
+    readonly titlePg?: boolean;
+    readonly evenAndOddHeaders?: boolean;
+}
+export interface Section {
+    readonly properties: SectionProperties;
+    readonly endIndex: number;
+}
+export interface DocumentModel {
+    readonly body: ReadonlyArray<BodyElement>;
+    readonly styleSheet: StyleSheet;
+    readonly numbering?: Numbering;
+    readonly section?: SectionProperties;
+}

package/dist/esm/font/arabic-joining.d.ts

@@ -0,0 +1,4 @@
+export type JoiningType = 'R' | 'L' | 'D' | 'C' | 'U' | 'T';
+export type ArabicForm = 'isol' | 'init' | 'medi' | 'fina';
+export declare function arabicJoiningType(cp: number): JoiningType;
+export declare function assignArabicForms(cps: ReadonlyArray<number>): Array<ArabicForm>;

package/dist/esm/font/arabic-joining.js

@@ -0,0 +1,97 @@
+//#region src/font/arabic-joining.ts
+var RIGHT_JOINING = new Set([
+	1570,
+	1571,
+	1572,
+	1573,
+	1575,
+	1577,
+	1583,
+	1584,
+	1585,
+	1586,
+	1608,
+	1649,
+	1650,
+	1651,
+	1653,
+	1654,
+	1655,
+	1672,
+	1673,
+	1674,
+	1675,
+	1676,
+	1677,
+	1678,
+	1679,
+	1680,
+	1681,
+	1682,
+	1683,
+	1684,
+	1685,
+	1686,
+	1687,
+	1688,
+	1689,
+	1728,
+	1731,
+	1732,
+	1733,
+	1734,
+	1735,
+	1736,
+	1737,
+	1738,
+	1739,
+	1741,
+	1743,
+	1746,
+	1747,
+	1749,
+	1774,
+	1775
+]);
+function isTransparentMark(cp) {
+	return cp >= 1552 && cp <= 1562 || cp >= 1611 && cp <= 1631 || cp === 1648 || cp >= 1750 && cp <= 1756 || cp >= 1759 && cp <= 1764 || cp === 1767 || cp === 1768 || cp >= 1770 && cp <= 1773;
+}
+function arabicJoiningType(cp) {
+	if (cp === 1600) return "C";
+	if (cp === 8205) return "C";
+	if (cp === 8204) return "U";
+	if (isTransparentMark(cp)) return "T";
+	if (RIGHT_JOINING.has(cp)) return "R";
+	if (cp >= 1568 && cp <= 1610 || cp >= 1646 && cp <= 1747 || cp === 1791) return "D";
+	return "U";
+}
+var canJoinRight = (t) => t === "R" || t === "D" || t === "C";
+var canJoinLeft = (t) => t === "L" || t === "D" || t === "C";
+function assignArabicForms(cps) {
+	const types = cps.map(arabicJoiningType);
+	const forms = new Array(cps.length).fill("isol");
+	const prevNonT = new Array(cps.length).fill(-1);
+	const nextNonT = new Array(cps.length).fill(-1);
+	let last = -1;
+	for (let i = 0; i < cps.length; i++) {
+		prevNonT[i] = last;
+		if (types[i] !== "T") last = i;
+	}
+	let nxt = -1;
+	for (let i = cps.length - 1; i >= 0; i--) {
+		nextNonT[i] = nxt;
+		if (types[i] !== "T") nxt = i;
+	}
+	for (let i = 0; i < cps.length; i++) {
+		const t = types[i];
+		if (t === "U" || t === "T") continue;
+		const p = prevNonT[i];
+		const n = nextNonT[i];
+		const joinsPrev = canJoinRight(t) && p >= 0 && canJoinLeft(types[p]);
+		const joinsNext = canJoinLeft(t) && n >= 0 && canJoinRight(types[n]);
+		forms[i] = joinsPrev && joinsNext ? "medi" : joinsPrev ? "fina" : joinsNext ? "init" : "isol";
+	}
+	return forms;
+}
+//#endregion
+export { assignArabicForms };

package/dist/esm/font/binary-reader.d.ts

@@ -0,0 +1,13 @@
+export declare class BigEndianReader {
+    readonly data: Uint8Array;
+    offset: number;
+    constructor(data: Uint8Array, offset?: number);
+    seek(offset: number): void;
+    skip(bytes: number): void;
+    u8(): number;
+    u16(): number;
+    i16(): number;
+    u32(): number;
+    i32(): number;
+    tag(): string;
+}

package/dist/esm/font/binary-reader.js

@@ -0,0 +1,44 @@
+//#region src/font/binary-reader.ts
+var BigEndianReader = class {
+	constructor(data, offset = 0) {
+		this.data = data;
+		this.offset = offset;
+	}
+	seek(offset) {
+		this.offset = offset;
+	}
+	skip(bytes) {
+		this.offset += bytes;
+	}
+	u8() {
+		return this.data[this.offset++];
+	}
+	u16() {
+		const d = this.data;
+		const p = this.offset;
+		this.offset += 2;
+		return d[p] << 8 | d[p + 1];
+	}
+	i16() {
+		const v = this.u16();
+		return v >= 32768 ? v - 65536 : v;
+	}
+	u32() {
+		const d = this.data;
+		const p = this.offset;
+		this.offset += 4;
+		return d[p] * 16777216 + (d[p + 1] << 16 | d[p + 2] << 8 | d[p + 3]);
+	}
+	i32() {
+		const v = this.u32();
+		return v >= 2147483648 ? v - 4294967296 : v;
+	}
+	tag() {
+		const d = this.data;
+		const p = this.offset;
+		this.offset += 4;
+		return String.fromCharCode(d[p], d[p + 1], d[p + 2], d[p + 3]);
+	}
+};
+//#endregion
+export { BigEndianReader };

package/dist/esm/font/font-registry.d.ts

@@ -0,0 +1,19 @@
+import { ParsedTtf } from './ttf-parser.js';
+export type FontVariant = 'regular' | 'bold' | 'italic' | 'boldItalic';
+export interface FontBytesByVariant {
+    readonly regular: Uint8Array;
+    readonly bold?: Uint8Array;
+    readonly italic?: Uint8Array;
+    readonly boldItalic?: Uint8Array;
+}
+export declare class FontRegistry {
+    private readonly fonts;
+    private constructor();
+    static fromBytes(input: FontBytesByVariant): FontRegistry;
+    resolveByStyle(bold: boolean, italic: boolean): {
+        variant: FontVariant;
+        parsed: ParsedTtf;
+    };
+    entries(): IterableIterator<[FontVariant, ParsedTtf]>;
+    hasVariant(v: FontVariant): boolean;
+}

package/dist/esm/font/font-registry.js

@@ -0,0 +1,39 @@
+import { parseTtf } from "./ttf-parser.js";
+//#region src/font/font-registry.ts
+var FontRegistry = class FontRegistry {
+	constructor(fonts) {
+		this.fonts = fonts;
+	}
+	static fromBytes(input) {
+		const map = /* @__PURE__ */ new Map();
+		map.set("regular", parseTtf(input.regular));
+		if (input.bold) map.set("bold", parseTtf(input.bold));
+		if (input.italic) map.set("italic", parseTtf(input.italic));
+		if (input.boldItalic) map.set("boldItalic", parseTtf(input.boldItalic));
+		return new FontRegistry(map);
+	}
+	resolveByStyle(bold, italic) {
+		const candidates = bold && italic ? [
+			"boldItalic",
+			"bold",
+			"italic",
+			"regular"
+		] : bold ? ["bold", "regular"] : italic ? ["italic", "regular"] : ["regular"];
+		for (const v of candidates) {
+			const parsed = this.fonts.get(v);
+			if (parsed) return {
+				variant: v,
+				parsed
+			};
+		}
+		throw new Error("FontRegistry has no regular font");
+	}
+	entries() {
+		return this.fonts.entries();
+	}
+	hasVariant(v) {
+		return this.fonts.has(v);
+	}
+};
+//#endregion
+export { FontRegistry };

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

@@ -0,0 +1,7 @@
+export { parseTtf } from './ttf-parser.js';
+export type { ParsedTtf, TtfTableInfo } from './ttf-parser.js';
+export { subsetTtf, glyphClosure } from './ttf-subset.js';
+export { FontRegistry } from './font-registry.js';
+export type { FontVariant, FontBytesByVariant } from './font-registry.js';
+export { parseGposKerning, parseGsubLigatures, shapeText } from './opentype-layout.js';
+export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';