@mark1russell7/typeset 0.1.1 → 0.1.2

package/build/chunks/font.js

@@ -0,0 +1,3550 @@
+import { fnv1a32 } from "@mark1russell7/rigor-generators";
+// src/fonts/tables.ts
+/** This function reads the header fields from `head`, `hhea` and `maxp`. */
+function readHeader(head, hhea, maxp) {
+	if (head.u32(12) !== 1594834165) throw new Error("the head table has a bad magic number");
+	return {
+		revision: head.u32(4),
+		checksumAdjustment: head.u32(8),
+		unitsPerEm: head.u16(18),
+		numberOfHMetrics: hhea.u16(34),
+		numGlyphs: maxp.u16(4)
+	};
+}
+/** This function gives the advance of each glyph in font units, from `hmtx`. */
+function readAdvances(hmtx, header) {
+	const advances = new Uint16Array(header.numGlyphs);
+	let last = 0;
+	for (let glyph = 0; glyph < header.numGlyphs; glyph++) {
+		if (glyph < header.numberOfHMetrics) last = hmtx.u16(glyph * 4);
+		advances[glyph] = last;
+	}
+	return advances;
+}
+/** This function gives the map from code points to glyphs of `cmap`. It uses a format 12 subtable if there is one, else a format 4 subtable. */
+function readCharacterMap(cmap) {
+	const count = cmap.u16(2);
+	let best;
+	for (let i = 0; i < count; i++) {
+		const record = 4 + i * 8;
+		const platform = cmap.u16(record);
+		const encoding = cmap.u16(record + 2);
+		const offset = cmap.u32(record + 4);
+		const format = cmap.u16(offset);
+		if (!(platform === 0 || platform === 3 && (encoding === 1 || encoding === 10))) continue;
+		const rank = format === 12 ? 2 : format === 4 ? 1 : 0;
+		if (rank > 0 && (best === void 0 || rank > best.rank)) best = {
+			rank,
+			offset
+		};
+	}
+	if (best === void 0) throw new Error("the cmap table has no Unicode subtable of format 4 or 12");
+	const table = cmap.part(best.offset);
+	const map = /* @__PURE__ */ new Map();
+	if (best.rank === 2) {
+		const groups = table.u32(12);
+		for (let g = 0; g < groups; g++) {
+			const at = 16 + g * 12;
+			const start = table.u32(at);
+			const end = table.u32(at + 4);
+			const glyph = table.u32(at + 8);
+			for (let c = start; c <= end; c++) map.set(c, glyph + c - start);
+		}
+		return map;
+	}
+	const segments = table.u16(6) / 2;
+	const ends = 14;
+	const starts = ends + segments * 2 + 2;
+	const deltas = starts + segments * 2;
+	const ranges = deltas + segments * 2;
+	for (let s = 0; s < segments; s++) {
+		const start = table.u16(starts + s * 2);
+		const end = table.u16(ends + s * 2);
+		const delta = table.u16(deltas + s * 2);
+		const range = table.u16(ranges + s * 2);
+		for (let c = start; c <= end && c !== 65535; c++) {
+			let glyph;
+			if (range === 0) glyph = c + delta & 65535;
+			else {
+				glyph = table.u16(ranges + s * 2 + range + (c - start) * 2);
+				if (glyph !== 0) glyph = glyph + delta & 65535;
+			}
+			if (glyph !== 0) map.set(c, glyph);
+		}
+	}
+	return map;
+}
+/** This function gives the class of a glyph in a ClassDef table. A glyph that the table does not list has the class 0. */
+function classOf(table, glyph) {
+	const format = table.u16(0);
+	if (format === 1) {
+		const start = table.u16(2);
+		const count = table.u16(4);
+		return glyph >= start && glyph < start + count ? table.u16(6 + (glyph - start) * 2) : 0;
+	}
+	if (format === 2) {
+		let low = 0;
+		let high = table.u16(2) - 1;
+		while (low <= high) {
+			const middle = low + high >> 1;
+			const at = 4 + middle * 6;
+			if (glyph < table.u16(at)) high = middle - 1;
+			else if (glyph > table.u16(at + 2)) low = middle + 1;
+			else return table.u16(at + 4);
+		}
+		return 0;
+	}
+	throw new Error(`the ClassDef format ${format} is unknown`);
+}
+/** This function gives the index of a glyph in a Coverage table, or -1 when the table does not cover the glyph. */
+function coverageIndex(table, glyph) {
+	const format = table.u16(0);
+	let low = 0;
+	let high = table.u16(2) - 1;
+	if (format === 1) {
+		while (low <= high) {
+			const middle = low + high >> 1;
+			const value = table.u16(4 + middle * 2);
+			if (glyph < value) high = middle - 1;
+			else if (glyph > value) low = middle + 1;
+			else return middle;
+		}
+		return -1;
+	}
+	if (format === 2) {
+		while (low <= high) {
+			const middle = low + high >> 1;
+			const at = 4 + middle * 6;
+			if (glyph < table.u16(at)) high = middle - 1;
+			else if (glyph > table.u16(at + 2)) low = middle + 1;
+			else return table.u16(at + 4) + glyph - table.u16(at);
+		}
+		return -1;
+	}
+	throw new Error(`the Coverage format ${format} is unknown`);
+}
+/** The GDEF glyph classes: 1 base, 2 ligature, 3 mark, 4 component. */
+function readGlyphClasses(gdef) {
+	if (gdef === void 0) return () => 0;
+	const offset = gdef.u16(4);
+	if (offset === 0) return () => 0;
+	const table = gdef.part(offset);
+	return (glyph) => classOf(table, glyph);
+}
+/** This function gives the size in bytes of a ValueRecord of the format `format`. */
+function valueSize(format) {
+	let bits = format & 255;
+	let size = 0;
+	while (bits !== 0) {
+		size += bits & 1;
+		bits >>= 1;
+	}
+	return size * 2;
+}
+/**
+* This function gives the XAdvance of a ValueRecord at `offset`, or 0 when the format has none. The offset of a device table
+* is relative to `parent`. A VariationIndex table adds its delta from `store`, not rounded, as HarfBuzz adds it. A device
+* table of hinting deltas adds nothing, because the shaper of the browser does not set a ppem.
+*/
+function xAdvance(table, offset, format, parent, store) {
+	const value = (format & 4) === 0 ? 0 : table.i16(offset + valueSize(format & 3));
+	let delta = 0;
+	if ((format & 64) !== 0 && store !== void 0) {
+		const device = table.u16(offset + valueSize(format & 63));
+		if (device !== 0 && parent.u16(device + 4) === 32768) delta = store.delta(parent.u16(device), parent.u16(device + 2));
+	}
+	return {
+		value: value + delta,
+		delta
+	};
+}
+/** This function makes the value of a pair from the XAdvance of its two glyphs. */
+function pairValue(first, second, skipSecond) {
+	return {
+		first: first.value,
+		second: second.value,
+		firstDelta: first.delta,
+		secondDelta: second.delta,
+		skipSecond
+	};
+}
+/** This function makes the pair function of one PairPos subtable. */
+function pairSubtable(table, store) {
+	const format = table.u16(0);
+	const coverage = table.part(table.u16(2));
+	const format1 = table.u16(4);
+	const format2 = table.u16(6);
+	const size1 = valueSize(format1);
+	const size2 = valueSize(format2);
+	const skipSecond = format2 !== 0;
+	if (format === 1) return (first, second) => {
+		const index = coverageIndex(coverage, first);
+		if (index < 0) return void 0;
+		const set = table.part(table.u16(10 + index * 2));
+		const recordSize = 2 + size1 + size2;
+		let low = 0;
+		let high = set.u16(0) - 1;
+		while (low <= high) {
+			const middle = low + high >> 1;
+			const at = 2 + middle * recordSize;
+			const glyph = set.u16(at);
+			if (second < glyph) high = middle - 1;
+			else if (second > glyph) low = middle + 1;
+			else return pairValue(xAdvance(set, at + 2, format1, set, store), xAdvance(set, at + 2 + size1, format2, set, store), skipSecond);
+		}
+	};
+	if (format === 2) {
+		const classes1 = table.part(table.u16(8));
+		const classes2 = table.part(table.u16(10));
+		const count1 = table.u16(12);
+		const count2 = table.u16(14);
+		return (first, second) => {
+			if (coverageIndex(coverage, first) < 0) return void 0;
+			const class1 = classOf(classes1, first);
+			const class2 = classOf(classes2, second);
+			if (class1 >= count1 || class2 >= count2) return void 0;
+			const at = 16 + (class1 * count2 + class2) * (size1 + size2);
+			return pairValue(xAdvance(table, at, format1, table, store), xAdvance(table, at + size1, format2, table, store), skipSecond);
+		};
+	}
+	throw new Error(`the PairPos format ${format} is unknown`);
+}
+/** This function gives the tags of the scripts to try, in order, for a script tag, as HarfBuzz tries them. */
+function scriptTags(script) {
+	return [
+		...script === "deva" ? ["dev2", "deva"] : [script],
+		"DFLT",
+		"dflt",
+		"latn"
+	];
+}
+/** The GPOS features with pair lookups that HarfBuzz applies to horizontal text. */
+const pairFeatures = /* @__PURE__ */ new Set(["kern", "dist"]);
+/** The lookup flag that selects a mark filtering set of GDEF. */
+const USE_MARK_FILTERING_SET$1 = 16;
+/**
+* This function gives the pair lookups of the features `kern` and `dist` of GPOS for a script, in the order of the lookup
+* list. The store gives the deltas of a variable font at its instance. The filter gives the mark filtering sets of GDEF.
+*/
+function readGposKerning(gpos, script, store, filter) {
+	const scripts = gpos.part(gpos.u16(4));
+	const features = gpos.part(gpos.u16(6));
+	const lookups = gpos.part(gpos.u16(8));
+	const scriptCount = scripts.u16(0);
+	let langSys;
+	for (const wanted of scriptTags(script)) {
+		for (let i = 0; i < scriptCount && langSys === void 0; i++) {
+			if (scripts.tag(2 + i * 6) !== wanted) continue;
+			const table = scripts.part(scripts.u16(2 + i * 6 + 4));
+			const fallback = table.u16(0);
+			if (fallback !== 0) langSys = table.part(fallback);
+		}
+		if (langSys !== void 0) break;
+	}
+	if (langSys === void 0) return [];
+	const indices = /* @__PURE__ */ new Set();
+	const featureCount = langSys.u16(4);
+	for (let i = 0; i < featureCount; i++) {
+		const record = 2 + langSys.u16(6 + i * 2) * 6;
+		if (!pairFeatures.has(features.tag(record))) continue;
+		const feature = features.part(features.u16(record + 4));
+		for (let k = 0; k < feature.u16(2); k++) indices.add(feature.u16(4 + k * 2));
+	}
+	return [...indices].sort((a, b) => a - b).flatMap((index) => {
+		const lookup = lookups.part(lookups.u16(2 + index * 2));
+		const subtables = [];
+		const type = lookup.u16(0);
+		for (let s = 0; s < lookup.u16(4); s++) {
+			let subtable = lookup.part(lookup.u16(6 + s * 2));
+			let subtype = type;
+			if (type === 9) {
+				subtype = subtable.u16(2);
+				subtable = subtable.part(subtable.u32(4));
+			}
+			if (subtype === 2) subtables.push(pairSubtable(subtable, store));
+		}
+		if (subtables.length === 0) return [];
+		const flags = lookup.u16(2);
+		const markSet = (flags & USE_MARK_FILTERING_SET$1) !== 0 && filter !== void 0 ? lookup.u16(6 + lookup.u16(4) * 2) : -1;
+		const skip = markSet < 0 ? void 0 : (glyph) => {
+			const kind = filter.glyphClass(glyph);
+			if ((flags & 2) !== 0 && kind === 1) return true;
+			if ((flags & 4) !== 0 && kind === 2) return true;
+			if (kind !== 3) return false;
+			return (flags & 8) !== 0 || !filter.inMarkSet(markSet, glyph);
+		};
+		return [{
+			flags,
+			...skip === void 0 ? {} : { skip },
+			pair(first, second) {
+				for (const subtable of subtables) {
+					const value = subtable(first, second);
+					if (value !== void 0) return value;
+				}
+			}
+		}];
+	});
+}
+/** This function gives the pairs of format 0 of the `kern` table, as one lookup. */
+function readKernTable(kern) {
+	if (kern.u16(0) !== 0) return [];
+	const pairs = /* @__PURE__ */ new Map();
+	const count = kern.u16(2);
+	let offset = 4;
+	for (let t = 0; t < count; t++) {
+		const length = kern.u16(offset + 2);
+		if ((kern.u16(offset + 4) & 65287) === 1) {
+			const n = kern.u16(offset + 6);
+			for (let i = 0; i < n; i++) {
+				const at = offset + 14 + i * 6;
+				const key = kern.u16(at) * 65536 + kern.u16(at + 2);
+				pairs.set(key, (pairs.get(key) ?? 0) + kern.i16(at + 4));
+			}
+		}
+		offset += length;
+	}
+	if (pairs.size === 0) return [];
+	return [{
+		flags: 0,
+		pair(first, second) {
+			const value = pairs.get(first * 65536 + second);
+			return value === void 0 ? void 0 : {
+				first: value,
+				second: 0,
+				skipSecond: false
+			};
+		}
+	}];
+}
+// src/fonts/binary.ts
+/** A big-endian reader over a part of a font file. The offsets are relative to the start of the part. */
+var Reader = class Reader {
+	bytes;
+	view;
+	constructor(bytes) {
+		this.bytes = bytes;
+		this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	}
+	get length() {
+		return this.bytes.byteLength;
+	}
+	u8(offset) {
+		return this.view.getUint8(offset);
+	}
+	u16(offset) {
+		return this.view.getUint16(offset);
+	}
+	i16(offset) {
+		return this.view.getInt16(offset);
+	}
+	u32(offset) {
+		return this.view.getUint32(offset);
+	}
+	tag(offset) {
+		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, length) {
+		const end = length === void 0 ? 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));
+	}
+};
+// src/fonts/sfnt.ts
+/** The tags of the WOFF2 table directory, in the order of the WOFF2 specification. */
+const knownTags = [
+	"cmap",
+	"head",
+	"hhea",
+	"hmtx",
+	"maxp",
+	"name",
+	"OS/2",
+	"post",
+	"cvt ",
+	"fpgm",
+	"glyf",
+	"loca",
+	"prep",
+	"CFF ",
+	"VORG",
+	"EBDT",
+	"EBLC",
+	"gasp",
+	"hdmx",
+	"kern",
+	"LTSH",
+	"PCLT",
+	"VDMX",
+	"vhea",
+	"vmtx",
+	"BASE",
+	"GDEF",
+	"GPOS",
+	"GSUB",
+	"EBSC",
+	"JSTF",
+	"MATH",
+	"CBDT",
+	"CBLC",
+	"COLR",
+	"CPAL",
+	"SVG ",
+	"sbix",
+	"acnt",
+	"avar",
+	"bdat",
+	"bloc",
+	"bsln",
+	"cvar",
+	"fdsc",
+	"feat",
+	"fmtx",
+	"fvar",
+	"gvar",
+	"hsty",
+	"just",
+	"lcar",
+	"mort",
+	"morx",
+	"opbd",
+	"prop",
+	"trak",
+	"Zapf",
+	"Silf",
+	"Glat",
+	"Gloc",
+	"Feat",
+	"Sill"
+];
+/** This function gives the tables of a TrueType, OpenType or WOFF2 file. */
+function readTables(bytes, decompress) {
+	const file = new Reader(bytes);
+	if (file.length < 12) throw new RangeError("the file is too short for a font");
+	const signature = file.tag(0);
+	if (signature === "wOF2") {
+		if (decompress === void 0) throw new Error("a WOFF2 file needs a Brotli decompress function");
+		return readWoff2(file, decompress);
+	}
+	if (signature === "wOFF") throw new Error("WOFF 1 files are not supported");
+	if (signature === "ttcf") throw new Error("font collections are not supported");
+	if (file.u32(0) !== 65536 && signature !== "OTTO" && signature !== "true") throw new Error(`the signature ${JSON.stringify(signature)} is not a font`);
+	const tables = /* @__PURE__ */ new Map();
+	const count = file.u16(4);
+	for (let i = 0; i < count; i++) {
+		const record = 12 + i * 16;
+		tables.set(file.tag(record), file.part(file.u32(record + 8), file.u32(record + 12)));
+	}
+	return tables;
+}
+/** This function reads a UIntBase128 number of WOFF2 and gives the number and the next offset. */
+function base128(file, offset) {
+	let value = 0;
+	for (let i = 0; i < 5; i++) {
+		const byte = file.u8(offset + i);
+		if (i === 0 && byte === 128) throw new RangeError("a UIntBase128 has a leading zero");
+		value = value * 128 + (byte & 127);
+		if ((byte & 128) === 0) return [value, offset + i + 1];
+	}
+	throw new RangeError("a UIntBase128 is longer than 5 bytes");
+}
+/**
+* This function gives the tables of a WOFF2 file. The `glyf` and `loca` tables stay in their transformed form,
+* because the width does not use them. A transformed `hmtx` table becomes a plain table again.
+*/
+function readWoff2(file, decompress) {
+	if (file.u32(4) === 1953784678) throw new Error("WOFF2 font collections are not supported");
+	const count = file.u16(12);
+	const compressedLength = file.u32(20);
+	let offset = 48;
+	const entries = [];
+	for (let i = 0; i < count; i++) {
+		const flags = file.u8(offset++);
+		let tag;
+		if ((flags & 63) === 63) {
+			tag = file.tag(offset);
+			offset += 4;
+		} else {
+			const known = knownTags[flags & 63];
+			if (known === void 0) throw new RangeError(`the WOFF2 tag index ${flags & 63} is unknown`);
+			tag = known;
+		}
+		const version = flags >> 6 & 3;
+		let length;
+		[length, offset] = base128(file, offset);
+		const transformed = tag === "glyf" || tag === "loca" ? version === 0 : version !== 0;
+		if (transformed) [length, offset] = base128(file, offset);
+		entries.push({
+			tag,
+			length,
+			transformed
+		});
+	}
+	const data = new Reader(decompress(file.bytes.subarray(offset, offset + compressedLength)));
+	const tables = /* @__PURE__ */ new Map();
+	let at = 0;
+	for (const entry of entries) {
+		tables.set(entry.tag, data.part(at, entry.length));
+		at += entry.length;
+	}
+	if (entries.find((entry) => entry.tag === "hmtx")?.transformed === true) tables.set("hmtx", untransformHmtx(tables));
+	return tables;
+}
+/** This function gives a plain `hmtx` table from the transform of WOFF2. Only the advances matter, so each side bearing is 0. */
+function untransformHmtx(tables) {
+	const source = tables.get("hmtx");
+	const hhea = tables.get("hhea");
+	if (hhea === void 0) throw new Error("a transformed hmtx needs hhea");
+	const metrics = hhea.u16(34);
+	const plain = new Uint8Array(metrics * 4);
+	const view = new DataView(plain.buffer);
+	for (let i = 0; i < metrics; i++) view.setUint16(i * 4, source.u16(1 + i * 2));
+	return new Reader(plain);
+}
+// src/fonts/substitution.ts
+/**
+* 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.
+*/
+const defaultFeatures = [
+	"ccmp",
+	"locl",
+	"rlig",
+	"liga",
+	"clig",
+	"calt",
+	"rclt"
+];
+/** The lookup flag that selects a mark filtering set of GDEF. */
+const USE_MARK_FILTERING_SET = 16;
+/** The largest depth of nested lookups, as in HarfBuzz. */
+const MAX_NESTING = 64;
+/** This function reads the glyph classes, the mark attachment classes and the mark filtering sets of GDEF. */
+function readGlyphFilter(gdef, glyphClass) {
+	const attachOffset = gdef === void 0 ? 0 : gdef.u16(10);
+	const attach = attachOffset === 0 ? void 0 : gdef.part(attachOffset);
+	const setsOffset = gdef === void 0 || gdef.u16(2) < 2 ? 0 : gdef.u16(12);
+	const sets = setsOffset === 0 ? void 0 : gdef.part(setsOffset);
+	return {
+		glyphClass,
+		markAttachClass: (glyph) => attach === void 0 ? 0 : classOf(attach, glyph),
+		inMarkSet(set, glyph) {
+			if (sets === void 0 || set >= sets.u16(2)) return false;
+			return coverageIndex(sets.part(sets.u32(4 + set * 4)), glyph) >= 0;
+		}
+	};
+}
+function records(table, at, count) {
+	return Array.from({ length: count }, (_, k) => ({
+		sequenceIndex: table.u16(at + k * 4),
+		lookupIndex: table.u16(at + k * 4 + 2)
+	}));
+}
+/** The lookups of one GSUB table. It reads each lookup at its first use. */
+var Gsub = class {
+	lookups;
+	filter;
+	cache = /* @__PURE__ */ new Map();
+	constructor(table, filter) {
+		this.lookups = table.part(table.u16(8));
+		this.filter = filter;
+	}
+	lookup(index) {
+		if (index >= this.lookups.u16(0)) return void 0;
+		let found = this.cache.get(index);
+		if (found === void 0) {
+			const table = this.lookups.part(this.lookups.u16(2 + index * 2));
+			const type = table.u16(0);
+			const flags = table.u16(2);
+			const count = table.u16(4);
+			const markSet = (flags & USE_MARK_FILTERING_SET) !== 0 ? table.u16(6 + count * 2) : -1;
+			const subtables = [];
+			let subtype = type;
+			for (let s = 0; s < count; s++) {
+				const subtable = table.part(table.u16(6 + s * 2));
+				if (type === 7) {
+					subtype = subtable.u16(2);
+					subtables.push(subtable.part(subtable.u32(4)));
+				} else subtables.push(subtable);
+			}
+			const { glyphClass, markAttachClass, inMarkSet } = this.filter;
+			const skip = (glyph) => {
+				const kind = glyphClass(glyph);
+				if ((flags & 2) !== 0 && kind === 1) return true;
+				if ((flags & 4) !== 0 && kind === 2) return true;
+				if (kind !== 3) return false;
+				if ((flags & 8) !== 0) return true;
+				if (markSet >= 0) return !inMarkSet(markSet, glyph);
+				const attach = flags >> 8;
+				return attach !== 0 && markAttachClass(glyph) !== attach;
+			};
+			found = {
+				type: subtype,
+				flags,
+				subtables,
+				skip
+			};
+			this.cache.set(index, found);
+		}
+		return found;
+	}
+	/**
+	* The masks of the glyphs of the current call of `applyAll`, or `undefined`. A substitution that adds or removes glyphs
+	* changes this array in the same way.
+	*/
+	masks;
+	/** The data of the glyphs of the current call of `applyRun`, or `undefined`. */
+	infos;
+	/** The mask of the current call of `applyRun`. Each input glyph needs a bit of it. */
+	lookupMask = -1;
+	/** It is true when the matched glyphs of the current call of `applyRun` need the syllable of the first glyph. */
+	perSyllable = false;
+	/**
+	* This function replaces `count` glyphs at `at` with `replacement`. Each new glyph gets the mask and the data of the
+	* glyph at `at`.
+	*/
+	splice(glyphs, at, count, replacement) {
+		glyphs.splice(at, count, ...replacement);
+		const masks = this.masks;
+		if (masks !== void 0) masks.splice(at, count, ...replacement.map(() => masks[at] ?? 0));
+		const infos = this.infos;
+		if (infos !== void 0) {
+			const source = infos[at];
+			infos.splice(at, count, ...replacement.map(() => ({ ...source })));
+		}
+	}
+	/** This function adds the glyph properties `set` to the glyph at `i`, and then removes the properties `clear`. */
+	setProps(i, set, clear = 0) {
+		const info = this.infos?.[i];
+		if (info !== void 0) info.props = (info.props | set) & ~clear;
+	}
+	/**
+	* This function tells if the glyph at `j` can match for the glyph at `first`. An input glyph needs a bit of the mask of
+	* the lookup. With the per-syllable matching, each glyph needs the syllable of `first`.
+	*/
+	admits(j, first, input) {
+		const infos = this.infos;
+		if (infos === void 0) return true;
+		if (input && (infos[j].mask & this.lookupMask) === 0) return false;
+		const syllable = infos[first]?.syllable ?? 0;
+		return !this.perSyllable || syllable === 0 || infos[j].syllable === syllable;
+	}
+	/** This function applies a lookup to all the glyphs with their data `infos`, as `applyInfos` of `SubstitutionLookup` tells. */
+	applyRun(index, glyphs, infos, mask, perSyllable) {
+		const lookup = this.lookup(index);
+		if (lookup === void 0) return;
+		this.infos = infos;
+		this.lookupMask = mask;
+		this.perSyllable = perSyllable;
+		try {
+			this.applyMasked(lookup, glyphs, (i) => (infos[i].mask & mask) !== 0);
+		} finally {
+			this.infos = void 0;
+			this.lookupMask = -1;
+			this.perSyllable = false;
+		}
+	}
+	/**
+	* This function applies a lookup to all the glyphs, as the main loop of a shaper does. With `masks`, the lookup starts
+	* only at a glyph whose mask has a bit of `mask`.
+	*/
+	applyAll(index, glyphs, masks, mask = -1) {
+		const lookup = this.lookup(index);
+		if (lookup === void 0) return;
+		this.masks = masks;
+		try {
+			this.applyMasked(lookup, glyphs, (i) => masks === void 0 || ((masks[i] ?? 0) & mask) !== 0);
+		} finally {
+			this.masks = void 0;
+		}
+	}
+	applyMasked(lookup, glyphs, selected) {
+		if (lookup.type === 8) {
+			for (let i = glyphs.length - 1; i >= 0; i--) if (selected(i) && !lookup.skip(glyphs[i])) this.reverse(lookup, glyphs, i);
+			return;
+		}
+		let i = 0;
+		while (i < glyphs.length) {
+			if (!selected(i) || lookup.skip(glyphs[i])) {
+				i++;
+				continue;
+			}
+			const before = glyphs.length;
+			const next = this.applyAt(lookup, glyphs, i, 0);
+			i = next < 0 ? i + 1 : next > i || glyphs.length < before ? next : i + 1;
+		}
+	}
+	/** This function applies the first subtable of a lookup that matches at `i`. It gives the next position, or -1. */
+	applyAt(lookup, glyphs, i, depth) {
+		for (const subtable of lookup.subtables) {
+			const next = this.subtable(lookup, subtable, glyphs, i, depth);
+			if (next >= 0) return next;
+		}
+		return -1;
+	}
+	nextOf(lookup, glyphs, from) {
+		for (let j = from; j < glyphs.length; j++) if (!lookup.skip(glyphs[j])) return j;
+		return -1;
+	}
+	previousOf(lookup, glyphs, from) {
+		for (let j = from; j >= 0; j--) if (!lookup.skip(glyphs[j])) return j;
+		return -1;
+	}
+	/**
+	* This function matches `count` glyphs after the position `i` with a test for each. It gives the positions of the
+	* matched glyphs, the first glyph at `i` included, or `undefined`.
+	*/
+	matchInput(lookup, glyphs, i, count, test) {
+		const positions = [i];
+		let at = i;
+		for (let k = 0; k < count; k++) {
+			at = this.nextOf(lookup, glyphs, at + 1);
+			if (at < 0 || !this.admits(at, i, true) || !test(k, glyphs[at])) return void 0;
+			positions.push(at);
+		}
+		return positions;
+	}
+	matchBacktrack(lookup, glyphs, i, count, test) {
+		let at = i;
+		for (let k = 0; k < count; k++) {
+			at = this.previousOf(lookup, glyphs, at - 1);
+			if (at < 0 || !this.admits(at, i, false) || !test(k, glyphs[at])) return false;
+		}
+		return true;
+	}
+	matchLookahead(lookup, glyphs, first, last, count, test) {
+		let at = last;
+		for (let k = 0; k < count; k++) {
+			at = this.nextOf(lookup, glyphs, at + 1);
+			if (at < 0 || !this.admits(at, first, false) || !test(k, glyphs[at])) return false;
+		}
+		return true;
+	}
+	/** This function applies the lookups of the records of a context rule at the matched positions. It gives the next position. */
+	applyRecords(glyphs, positions, list, depth) {
+		if (depth < MAX_NESTING) for (const record of list) {
+			const at = positions[record.sequenceIndex];
+			const nested = this.lookup(record.lookupIndex);
+			if (at === void 0 || at >= glyphs.length || nested === void 0 || nested.skip(glyphs[at])) continue;
+			const before = glyphs.length;
+			if (nested.type === 8) this.reverse(nested, glyphs, at);
+			else this.applyAt(nested, glyphs, at, depth + 1);
+			const delta = glyphs.length - before;
+			if (delta > 0) {
+				for (let k = record.sequenceIndex + 1; k < positions.length; k++) positions[k] = positions[k] + delta;
+				positions.splice(record.sequenceIndex + 1, 0, ...Array.from({ length: delta }, (_, k) => at + 1 + k));
+			} else if (delta < 0) {
+				positions.splice(record.sequenceIndex + 1, Math.min(-delta, positions.length - record.sequenceIndex - 1));
+				for (let k = record.sequenceIndex + 1; k < positions.length; k++) positions[k] = positions[k] + delta;
+			}
+		}
+		return Math.min(glyphs.length, positions[positions.length - 1] + 1);
+	}
+	reverse(lookup, glyphs, i) {
+		for (const t of lookup.subtables) {
+			const index = coverageIndex(t.part(t.u16(2)), glyphs[i]);
+			if (index < 0) continue;
+			const backCount = t.u16(4);
+			const aheadAt = 6 + backCount * 2;
+			const aheadCount = t.u16(aheadAt);
+			const substituteAt = aheadAt + 2 + aheadCount * 2;
+			if (!this.matchBacktrack(lookup, glyphs, i, backCount, (k, g) => coverageIndex(t.part(t.u16(6 + k * 2)), g) >= 0)) continue;
+			if (!this.matchLookahead(lookup, glyphs, i, i, aheadCount, (k, g) => coverageIndex(t.part(t.u16(aheadAt + 2 + k * 2)), g) >= 0)) continue;
+			glyphs[i] = t.u16(substituteAt + 2 + index * 2);
+			this.setProps(i, 16);
+			return true;
+		}
+		return false;
+	}
+	/** This function tells if a lookup changes the sequence `glyphs` with no context, as `wouldApply` of `SubstitutionLookup` tells. */
+	wouldApply(index, glyphs) {
+		const lookup = this.lookup(index);
+		if (lookup === void 0 || glyphs.length === 0) return false;
+		const [first] = glyphs;
+		return lookup.subtables.some((t) => {
+			const format = t.u16(0);
+			if (lookup.type === 1 || lookup.type === 2 || lookup.type === 3 || lookup.type === 8) return glyphs.length === 1 && coverageIndex(t.part(t.u16(2)), first) >= 0;
+			if (lookup.type === 4) {
+				const index = coverageIndex(t.part(t.u16(2)), first);
+				if (index < 0) return false;
+				const set = t.part(t.u16(6 + index * 2));
+				return Array.from({ length: set.u16(0) }, (_, l) => set.part(set.u16(2 + l * 2))).some((ligature) => ligature.u16(2) === glyphs.length && glyphs.every((g, k) => k === 0 || ligature.u16(4 + (k - 1) * 2) === g));
+			}
+			if (lookup.type !== 5 && lookup.type !== 6) return false;
+			const chain = lookup.type === 6;
+			if (format === 3) {
+				const backCount = chain ? t.u16(2) : 0;
+				const inputAt = chain ? 4 + backCount * 2 : 2;
+				const count = t.u16(inputAt);
+				const coverageAt = chain ? inputAt + 2 : 6;
+				if (chain && (backCount !== 0 || t.u16(inputAt + 2 + count * 2) !== 0)) return false;
+				return count === glyphs.length && glyphs.every((g, k) => coverageIndex(t.part(t.u16(coverageAt + k * 2)), g) >= 0);
+			}
+			const index = coverageIndex(t.part(t.u16(2)), first);
+			if (index < 0) return false;
+			const classes = format === 2 ? t.part(t.u16(chain ? 6 : 4)) : void 0;
+			const value = (g) => classes === void 0 ? g : classOf(classes, g);
+			const setIndex = classes === void 0 ? index : value(first);
+			const setCountAt = chain ? format === 2 ? 10 : 4 : format === 2 ? 6 : 4;
+			if (setIndex >= t.u16(setCountAt) || t.u16(setCountAt + 2 + setIndex * 2) === 0) return false;
+			const set = t.part(t.u16(setCountAt + 2 + setIndex * 2));
+			for (let r = 0; r < set.u16(0); r++) {
+				const rule = set.part(set.u16(2 + r * 2));
+				const backCount = chain ? rule.u16(0) : 0;
+				const inputAt = chain ? 2 + backCount * 2 : 0;
+				const count = rule.u16(inputAt);
+				const inputStart = chain ? inputAt + 2 : 4;
+				if (chain && (backCount !== 0 || rule.u16(inputStart + Math.max(0, count - 1) * 2) !== 0)) continue;
+				if (count === glyphs.length && glyphs.every((g, k) => k === 0 || value(g) === rule.u16(inputStart + (k - 1) * 2))) return true;
+			}
+			return false;
+		});
+	}
+	/** This function applies one subtable at `i`. It gives the next position, or -1 when the subtable does not match. */
+	subtable(lookup, t, glyphs, i, depth) {
+		const glyph = glyphs[i];
+		const format = t.u16(0);
+		switch (lookup.type) {
+			case 1: {
+				const index = coverageIndex(t.part(t.u16(2)), glyph);
+				if (index < 0) return -1;
+				glyphs[i] = format === 1 ? glyph + t.i16(4) & 65535 : t.u16(6 + index * 2);
+				this.setProps(i, 16);
+				return i + 1;
+			}
+			case 2: {
+				const index = coverageIndex(t.part(t.u16(2)), glyph);
+				if (index < 0) return -1;
+				const sequence = t.part(t.u16(6 + index * 2));
+				const replacement = Array.from({ length: sequence.u16(0) }, (_, k) => sequence.u16(2 + k * 2));
+				this.splice(glyphs, i, 1, replacement);
+				for (let k = 0; k < replacement.length; k++) this.setProps(i + k, replacement.length > 1 ? 80 : 16);
+				return i + replacement.length;
+			}
+			case 3: {
+				const index = coverageIndex(t.part(t.u16(2)), glyph);
+				if (index < 0) return -1;
+				const set = t.part(t.u16(6 + index * 2));
+				if (set.u16(0) > 0) glyphs[i] = set.u16(2);
+				this.setProps(i, 16);
+				return i + 1;
+			}
+			case 4: {
+				const index = coverageIndex(t.part(t.u16(2)), glyph);
+				if (index < 0) return -1;
+				const set = t.part(t.u16(6 + index * 2));
+				for (let l = 0; l < set.u16(0); l++) {
+					const ligature = set.part(set.u16(2 + l * 2));
+					const components = ligature.u16(2);
+					const positions = this.matchInput(lookup, glyphs, i, components - 1, (k, g) => g === ligature.u16(4 + k * 2));
+					if (positions === void 0) continue;
+					glyphs[i] = ligature.u16(0);
+					this.setProps(i, 48, 64);
+					for (let k = positions.length - 1; k >= 1; k--) this.splice(glyphs, positions[k], 1, []);
+					return i + 1;
+				}
+				return -1;
+			}
+			case 5: return this.context(lookup, t, glyphs, i, depth);
+			case 6: return this.chainContext(lookup, t, glyphs, i, depth);
+			case 8: return this.reverse(lookup, glyphs, i) ? i + 1 : -1;
+			default: return -1;
+		}
+	}
+	context(lookup, t, glyphs, i, depth) {
+		const glyph = glyphs[i];
+		const format = t.u16(0);
+		if (format === 3) {
+			const count = t.u16(2);
+			const recordCount = t.u16(4);
+			if (count === 0 || coverageIndex(t.part(t.u16(6)), glyph) < 0) return -1;
+			const positions = this.matchInput(lookup, glyphs, i, count - 1, (k, g) => coverageIndex(t.part(t.u16(8 + k * 2)), g) >= 0);
+			if (positions === void 0) return -1;
+			return this.applyRecords(glyphs, positions, records(t, 6 + count * 2, recordCount), depth);
+		}
+		const index = coverageIndex(t.part(t.u16(2)), glyph);
+		if (index < 0) return -1;
+		const classes = format === 2 ? t.part(t.u16(4)) : void 0;
+		const setIndex = classes === void 0 ? index : classOf(classes, glyph);
+		if (setIndex >= t.u16(classes === void 0 ? 4 : 6)) return -1;
+		const setOffset = t.u16((classes === void 0 ? 6 : 8) + setIndex * 2);
+		if (setOffset === 0) return -1;
+		const set = t.part(setOffset);
+		const value = (g) => classes === void 0 ? g : classOf(classes, g);
+		for (let r = 0; r < set.u16(0); r++) {
+			const rule = set.part(set.u16(2 + r * 2));
+			const count = rule.u16(0);
+			const recordCount = rule.u16(2);
+			const positions = this.matchInput(lookup, glyphs, i, count - 1, (k, g) => value(g) === rule.u16(4 + k * 2));
+			if (positions === void 0) continue;
+			return this.applyRecords(glyphs, positions, records(rule, 4 + (count - 1) * 2, recordCount), depth);
+		}
+		return -1;
+	}
+	chainContext(lookup, t, glyphs, i, depth) {
+		const glyph = glyphs[i];
+		const format = t.u16(0);
+		if (format === 3) {
+			const backCount = t.u16(2);
+			const inputAt = 4 + backCount * 2;
+			const inputCount = t.u16(inputAt);
+			const aheadAt = inputAt + 2 + inputCount * 2;
+			const aheadCount = t.u16(aheadAt);
+			const recordsAt = aheadAt + 2 + aheadCount * 2;
+			const covers = (offset, g) => coverageIndex(t.part(t.u16(offset)), g) >= 0;
+			if (inputCount === 0 || !covers(inputAt + 2, glyph)) return -1;
+			if (!this.matchBacktrack(lookup, glyphs, i, backCount, (k, g) => covers(4 + k * 2, g))) return -1;
+			const positions = this.matchInput(lookup, glyphs, i, inputCount - 1, (k, g) => covers(inputAt + 4 + k * 2, g));
+			if (positions === void 0) return -1;
+			if (!this.matchLookahead(lookup, glyphs, i, positions[positions.length - 1], aheadCount, (k, g) => covers(aheadAt + 2 + k * 2, g))) return -1;
+			return this.applyRecords(glyphs, positions, records(t, recordsAt + 2, t.u16(recordsAt)), depth);
+		}
+		const index = coverageIndex(t.part(t.u16(2)), glyph);
+		if (index < 0) return -1;
+		const byClass = format === 2;
+		const backClasses = byClass ? t.part(t.u16(4)) : void 0;
+		const inputClasses = byClass ? t.part(t.u16(6)) : void 0;
+		const aheadClasses = byClass ? t.part(t.u16(8)) : void 0;
+		const setIndex = inputClasses === void 0 ? index : classOf(inputClasses, glyph);
+		if (setIndex >= t.u16(byClass ? 10 : 4)) return -1;
+		const setOffset = t.u16((byClass ? 12 : 6) + setIndex * 2);
+		if (setOffset === 0) return -1;
+		const set = t.part(setOffset);
+		const valueIn = (classes, g) => classes === void 0 ? g : classOf(classes, g);
+		for (let r = 0; r < set.u16(0); r++) {
+			const rule = set.part(set.u16(2 + r * 2));
+			const backCount = rule.u16(0);
+			const inputAt = 2 + backCount * 2;
+			const inputCount = rule.u16(inputAt);
+			const aheadAt = inputAt + 2 + Math.max(0, inputCount - 1) * 2;
+			const aheadCount = rule.u16(aheadAt);
+			const recordsAt = aheadAt + 2 + aheadCount * 2;
+			if (!this.matchBacktrack(lookup, glyphs, i, backCount, (k, g) => valueIn(backClasses, g) === rule.u16(2 + k * 2))) continue;
+			const positions = this.matchInput(lookup, glyphs, i, inputCount - 1, (k, g) => valueIn(inputClasses, g) === rule.u16(inputAt + 2 + k * 2));
+			if (positions === void 0) continue;
+			if (!this.matchLookahead(lookup, glyphs, i, positions[positions.length - 1], aheadCount, (k, g) => valueIn(aheadClasses, g) === rule.u16(aheadAt + 2 + k * 2))) continue;
+			return this.applyRecords(glyphs, positions, records(rule, recordsAt + 2, rule.u16(recordsAt)), depth);
+		}
+		return -1;
+	}
+};
+/**
+* This function gives the lookups of the features `features` of GSUB for a script, in the order of the lookup list, as
+* HarfBuzz applies them. The lookups include the lookups of the necessary feature of the language system.
+*/
+function readSubstitutions(gsub, script, features, filter) {
+	const scripts = gsub.part(gsub.u16(4));
+	const featureList = gsub.part(gsub.u16(6));
+	const scriptCount = scripts.u16(0);
+	let langSys;
+	for (const wanted of scriptTags(script)) {
+		for (let i = 0; i < scriptCount && langSys === void 0; i++) {
+			if (scripts.tag(2 + i * 6) !== wanted) continue;
+			const table = scripts.part(scripts.u16(2 + i * 6 + 4));
+			const fallback = table.u16(0);
+			if (fallback !== 0) langSys = table.part(fallback);
+		}
+		if (langSys !== void 0) break;
+	}
+	if (langSys === void 0 || features.length === 0) return [];
+	const wanted = new Set(features);
+	const indices = /* @__PURE__ */ new Map();
+	const add = (featureIndex, required) => {
+		const record = 2 + featureIndex * 6;
+		if (featureIndex >= featureList.u16(0)) return;
+		const tag = featureList.tag(record);
+		if (!required && !wanted.has(tag)) return;
+		const feature = featureList.part(featureList.u16(record + 4));
+		for (let k = 0; k < feature.u16(2); k++) {
+			const index = feature.u16(4 + k * 2);
+			const tags = indices.get(index) ?? [];
+			if (!tags.includes(tag)) tags.push(tag);
+			indices.set(index, tags);
+		}
+	};
+	const required = langSys.u16(2);
+	if (required !== 65535) add(required, true);
+	for (let i = 0; i < langSys.u16(4); i++) add(langSys.u16(6 + i * 2), false);
+	const table = new Gsub(gsub, filter);
+	const result = [];
+	for (const [index, tags] of [...indices].sort(([a], [b]) => a - b)) {
+		const lookup = table.lookup(index);
+		if (lookup === void 0) continue;
+		result.push({
+			index,
+			type: lookup.type,
+			flags: lookup.flags,
+			features: tags,
+			apply: (glyphs, masks, mask) => table.applyAll(index, glyphs, masks, mask),
+			applyInfos: (glyphs, infos, mask, perSyllable) => table.applyRun(index, glyphs, infos, mask, perSyllable),
+			wouldApply: (glyphs) => table.wouldApply(index, glyphs)
+		});
+	}
+	return result;
+}
+// src/fonts/variations.ts
+/** This function reads a 16.16 fixed number. */
+function fixed(table, offset) {
+	return (table.u16(offset) << 16 >> 16) + table.u16(offset + 2) / 65536;
+}
+/** This function reads a 2.14 fixed number. */
+function f2dot14(table, offset) {
+	return table.i16(offset) / 16384;
+}
+/** This function rounds a number to the 2.14 grid, as HarfBuzz and FreeType do with each normalized coordinate. */
+function toF2dot14(value) {
+	return Math.round(value * 16384) / 16384;
+}
+/** This function gives the axes of `fvar`. */
+function readAxes(fvar) {
+	const offset = fvar.u16(4);
+	const count = fvar.u16(8);
+	const size = fvar.u16(10);
+	const axes = [];
+	for (let i = 0; i < count; i++) {
+		const at = offset + i * size;
+		axes.push({
+			tag: fvar.tag(at),
+			min: fixed(fvar, at + 4),
+			default: fixed(fvar, at + 8),
+			max: fixed(fvar, at + 12)
+		});
+	}
+	return axes;
+}
+/**
+* This function gives the normalized coordinates of an instance. Each coordinate is in -1 to 1, on the 2.14 grid. The
+* segment maps of `avar` change it when the font has them. A value outside the range of an axis is clamped to the range.
+*/
+function normalize$1(axes, avar, instance) {
+	const coordinates = axes.map((axis) => {
+		const value = Math.min(axis.max, Math.max(axis.min, instance[axis.tag] ?? axis.default));
+		if (value < axis.default) return toF2dot14(axis.default === axis.min ? 0 : (value - axis.default) / (axis.default - axis.min));
+		if (value > axis.default) return toF2dot14(axis.max === axis.default ? 0 : (value - axis.default) / (axis.max - axis.default));
+		return 0;
+	});
+	if (avar === void 0 || avar.u16(0) !== 1) return coordinates;
+	let at = 8;
+	const count = Math.min(avar.u16(6), axes.length);
+	for (let a = 0; a < count; a++) {
+		const pairs = avar.u16(at);
+		const from = [];
+		const to = [];
+		for (let p = 0; p < pairs; p++) {
+			from.push(f2dot14(avar, at + 2 + p * 4));
+			to.push(f2dot14(avar, at + 4 + p * 4));
+		}
+		at += 2 + pairs * 4;
+		coordinates[a] = toF2dot14(mapSegment(from, to, coordinates[a]));
+	}
+	return coordinates;
+}
+/** This function maps a coordinate through one segment map of `avar`, by linear interpolation between its points. */
+function mapSegment(from, to, value) {
+	if (from.length === 0) return value;
+	if (value <= from[0]) return to[0] + value - from[0];
+	for (let i = 1; i < from.length; i++) {
+		if (value === from[i]) return to[i];
+		if (value < from[i]) return to[i - 1] + (value - from[i - 1]) * (to[i] - to[i - 1]) / (from[i] - from[i - 1]);
+	}
+	return to[to.length - 1] + value - from[from.length - 1];
+}
+/** This function reads an ItemVariationStore and computes the scalar of each region at the coordinates. */
+function readVariationStore(store, coordinates) {
+	const regions = store.part(store.u32(2));
+	const axisCount = regions.u16(0);
+	const regionCount = regions.u16(2);
+	const scalars = [];
+	for (let r = 0; r < regionCount; r++) {
+		let scalar = 1;
+		for (let a = 0; a < axisCount && scalar !== 0; a++) {
+			const at = 4 + (r * axisCount + a) * 6;
+			scalar *= axisScalar(f2dot14(regions, at), f2dot14(regions, at + 2), f2dot14(regions, at + 4), coordinates[a] ?? 0);
+		}
+		scalars.push(scalar);
+	}
+	const dataCount = store.u16(6);
+	const data = Array.from({ length: dataCount }, (_, i) => store.part(store.u32(8 + i * 4)));
+	return { delta(outer, inner) {
+		const table = data[outer];
+		if (table === void 0 || inner >= table.u16(0)) return 0;
+		const wordField = table.u16(2);
+		const longWords = (wordField & 32768) !== 0;
+		const words = wordField & 32767;
+		const count = table.u16(4);
+		const wordSize = longWords ? 4 : 2;
+		const smallSize = longWords ? 2 : 1;
+		const rowSize = words * wordSize + (count - words) * smallSize;
+		let at = 6 + count * 2 + inner * rowSize;
+		let sum = 0;
+		for (let i = 0; i < count; i++) {
+			let value;
+			if (i < words) {
+				value = longWords ? table.u32(at) | 0 : table.i16(at);
+				at += wordSize;
+			} else {
+				value = longWords ? table.i16(at) : table.u8(at) << 24 >> 24;
+				at += smallSize;
+			}
+			const scalar = scalars[table.u16(6 + i * 2)] ?? 0;
+			if (scalar !== 0) sum += scalar * value;
+		}
+		return sum;
+	} };
+}
+/** This function gives the scalar of one axis of a region, as the OpenType specification defines it. */
+function axisScalar(start, peak, end, value) {
+	if (start > peak || peak > end) return 1;
+	if (start < 0 && end > 0 && peak !== 0) return 1;
+	if (peak === 0 || value === peak) return 1;
+	if (value <= start || value >= end) return 0;
+	return value < peak ? (value - start) / (peak - start) : (end - value) / (end - peak);
+}
+/** This function gives the outer and inner index of a glyph in a DeltaSetIndexMap. A glyph after the end uses the last entry. */
+function mapIndex(map, index) {
+	const format = map.u8(0);
+	const entryFormat = map.u8(1);
+	const count = format === 0 ? map.u16(2) : map.u32(2);
+	const start = format === 0 ? 4 : 6;
+	if (count === 0) return [0, index];
+	const size = (entryFormat >> 4 & 3) + 1;
+	const innerBits = (entryFormat & 15) + 1;
+	const at = start + Math.min(index, count - 1) * size;
+	let entry = 0;
+	for (let i = 0; i < size; i++) entry = entry * 256 + map.u8(at + i);
+	const innerCount = 2 ** innerBits;
+	return [Math.floor(entry / innerCount), entry % innerCount];
+}
+/**
+* This function gives the advances of an instance. With `round`, each delta of `HVAR` is rounded to whole font units, as
+* FreeType rounds it: a half goes up. With `exact`, the delta keeps its fraction. The advances stay as they are when the
+* font has no `HVAR` table.
+*/
+function instanceAdvances(advances, hvar, coordinates, deltas = "round") {
+	const result = Float64Array.from(advances);
+	if (hvar === void 0 || coordinates.every((value) => value === 0)) return result;
+	const store = readVariationStore(hvar.part(hvar.u32(4)), coordinates);
+	const mapOffset = hvar.u32(8);
+	const map = mapOffset === 0 ? void 0 : hvar.part(mapOffset);
+	for (let glyph = 0; glyph < result.length; glyph++) {
+		const [outer, inner] = map === void 0 ? [0, glyph] : mapIndex(map, glyph);
+		const delta = store.delta(outer, inner);
+		result[glyph] = advances[glyph] + (deltas === "round" ? Math.round(delta) : delta);
+	}
+	return result;
+}
+// src/fonts/gvar.ts
+/** The composite flags of `glyf` that change the length of a component record. */
+const ARG_1_AND_2_ARE_WORDS = 1;
+const WE_HAVE_A_SCALE = 8;
+const MORE_COMPONENTS = 32;
+const WE_HAVE_AN_X_AND_Y_SCALE = 64;
+const WE_HAVE_A_TWO_BY_TWO = 128;
+/** The composite flag that gives the metrics of the component to the composite glyph. */
+const USE_MY_METRICS = 512;
+/**
+* This function reads the composite records that start at `at`. It gives their length in bytes and the count of
+* components. It also gives the first component with the flag USE_MY_METRICS, or -1.
+*/
+function components(glyph, at) {
+	let count = 0;
+	let offset = at;
+	let metrics = -1;
+	for (;;) {
+		const flags = glyph.u16(offset);
+		if ((flags & USE_MY_METRICS) !== 0 && metrics < 0) metrics = glyph.u16(offset + 2);
+		offset += 4 + ((flags & ARG_1_AND_2_ARE_WORDS) !== 0 ? 4 : 2);
+		if ((flags & WE_HAVE_A_SCALE) !== 0) offset += 2;
+		else if ((flags & WE_HAVE_AN_X_AND_Y_SCALE) !== 0) offset += 4;
+		else if ((flags & WE_HAVE_A_TWO_BY_TWO) !== 0) offset += 8;
+		count++;
+		if ((flags & MORE_COMPONENTS) === 0) return {
+			count,
+			length: offset - at,
+			metrics
+		};
+	}
+}
+/**
+* This function gives the points of each glyph. A glyph of contours has the points of its contours. A composite glyph
+* has one point for each component.
+*/
+function readPointCounts(glyf, loca, indexToLocFormat, numGlyphs) {
+	const counts = new Uint32Array(numGlyphs);
+	const metrics = new Int32Array(numGlyphs).fill(-1);
+	const offsetOf = (glyph) => indexToLocFormat === 0 ? loca.u16(glyph * 2) * 2 : loca.u32(glyph * 4);
+	for (let glyph = 0; glyph < numGlyphs; glyph++) {
+		const start = offsetOf(glyph);
+		if (offsetOf(glyph + 1) <= start) continue;
+		const contours = glyf.i16(start);
+		if (contours > 0) counts[glyph] = glyf.u16(start + 10 + (contours - 1) * 2) + 1;
+		else if (contours < 0) {
+			const found = components(glyf, start + 10);
+			counts[glyph] = found.count;
+			metrics[glyph] = found.metrics;
+		}
+	}
+	return {
+		counts,
+		metrics
+	};
+}
+/** This function reads a 255UInt16 of WOFF2. It gives the value and the next offset. */
+function read255(stream, at) {
+	const code = stream.u8(at);
+	if (code === 253) return [stream.u16(at + 1), at + 3];
+	if (code === 254) return [stream.u8(at + 1) + 506, at + 2];
+	if (code === 255) return [stream.u8(at + 1) + 253, at + 2];
+	return [code, at + 1];
+}
+/** This function gives the points of each glyph from the transformed `glyf` table of WOFF2. */
+function readTransformedPointCounts(glyf, numGlyphs) {
+	const counts = new Uint32Array(numGlyphs);
+	const metrics = new Int32Array(numGlyphs).fill(-1);
+	const sizes = Array.from({ length: 7 }, (_, i) => glyf.u32(8 + i * 4));
+	const contourStream = glyf.part(36, sizes[0]);
+	const pointStream = glyf.part(36 + sizes[0], sizes[1]);
+	const compositeStream = glyf.part(36 + sizes[0] + sizes[1] + sizes[2] + sizes[3], sizes[4]);
+	let pointAt = 0;
+	let compositeAt = 0;
+	const glyphs = Math.min(numGlyphs, glyf.u16(4));
+	for (let glyph = 0; glyph < glyphs; glyph++) {
+		const contours = contourStream.i16(glyph * 2);
+		if (contours > 0) {
+			let total = 0;
+			for (let c = 0; c < contours; c++) {
+				const [points, next] = read255(pointStream, pointAt);
+				total += points;
+				pointAt = next;
+			}
+			counts[glyph] = total;
+		} else if (contours < 0) {
+			const found = components(compositeStream, compositeAt);
+			counts[glyph] = found.count;
+			metrics[glyph] = found.metrics;
+			compositeAt += found.length;
+		}
+	}
+	return {
+		counts,
+		metrics
+	};
+}
+/** This function reads packed point numbers. It gives the point numbers, or `undefined` for all the points, and the next offset. */
+function readPoints(data, at) {
+	let count = data.u8(at++);
+	if ((count & 128) !== 0) count = (count & 127) << 8 | data.u8(at++);
+	if (count === 0) return [void 0, at];
+	const points = [];
+	let last = 0;
+	while (points.length < count) {
+		const control = data.u8(at++);
+		const words = (control & 128) !== 0;
+		const run = (control & 127) + 1;
+		for (let k = 0; k < run && points.length < count; k++) {
+			last += words ? data.u16(at) : data.u8(at);
+			at += words ? 2 : 1;
+			points.push(last);
+		}
+	}
+	return [points, at];
+}
+/** This function reads `count` packed deltas. It gives the deltas and the next offset. */
+function readDeltas(data, at, count) {
+	const deltas = [];
+	while (deltas.length < count) {
+		const control = data.u8(at++);
+		const run = (control & 63) + 1;
+		const kind = control & 192;
+		for (let k = 0; k < run && deltas.length < count; k++) if (kind === 128) deltas.push(0);
+		else if (kind === 64) {
+			deltas.push(data.i16(at));
+			at += 2;
+		} else if (kind === 192) {
+			deltas.push(data.u32(at) | 0);
+			at += 4;
+		} else deltas.push(data.u8(at++) << 24 >> 24);
+	}
+	return [deltas, at];
+}
+/**
+* This function gives the advance delta of each glyph at the coordinates, from the phantom points of `gvar`. The delta
+* is the x delta of the second phantom point minus the x delta of the first. With `round`, the difference is rounded to
+* whole font units, and a half goes away from 0, as HarfBuzz rounds it.
+*/
+function gvarAdvanceDeltas(gvar, pointCounts, coordinates, deltas) {
+	const axisCount = gvar.u16(4);
+	const sharedCount = gvar.u16(6);
+	const sharedAt = gvar.u32(8);
+	const glyphCount = Math.min(gvar.u16(12), pointCounts.length);
+	const longOffsets = (gvar.u16(14) & 1) !== 0;
+	const dataAt = gvar.u32(16);
+	const offsetOf = (glyph) => longOffsets ? gvar.u32(20 + glyph * 4) : gvar.u16(20 + glyph * 2) * 2;
+	const peakOf = (at) => Array.from({ length: axisCount }, (_, a) => gvar.i16(at + a * 2) / 16384);
+	const shared = Array.from({ length: sharedCount }, (_, t) => peakOf(sharedAt + t * axisCount * 2));
+	const result = new Float64Array(pointCounts.length);
+	for (let glyph = 0; glyph < glyphCount; glyph++) {
+		const start = offsetOf(glyph);
+		const end = offsetOf(glyph + 1);
+		if (end <= start) continue;
+		const data = gvar.part(dataAt + start, end - start);
+		const tupleCount = data.u16(0) & 4095;
+		const sharedPoints = (data.u16(0) & 32768) !== 0;
+		let serialized = data.u16(2);
+		let header = 4;
+		const allPoints = pointCounts[glyph] + 4;
+		let sharedList;
+		if (sharedPoints) [sharedList, serialized] = readPoints(data, serialized);
+		const first = pointCounts[glyph];
+		let left = 0;
+		let right = 0;
+		for (let t = 0; t < tupleCount; t++) {
+			const size = data.u16(header);
+			const index = data.u16(header + 2);
+			header += 4;
+			let peak;
+			if ((index & 32768) !== 0) {
+				peak = Array.from({ length: axisCount }, (_, a) => data.i16(header + a * 2) / 16384);
+				header += axisCount * 2;
+			} else peak = shared[index & 4095] ?? [];
+			let startTuple;
+			let endTuple;
+			if ((index & 16384) !== 0) {
+				startTuple = Array.from({ length: axisCount }, (_, a) => data.i16(header + a * 2) / 16384);
+				endTuple = Array.from({ length: axisCount }, (_, a) => data.i16(header + axisCount * 2 + a * 2) / 16384);
+				header += axisCount * 4;
+			}
+			let scalar = 1;
+			for (let a = 0; a < axisCount && scalar !== 0; a++) {
+				const p = peak[a] ?? 0;
+				const s = startTuple?.[a] ?? Math.min(p, 0);
+				const e = endTuple?.[a] ?? Math.max(p, 0);
+				scalar *= axisScalar(s, p, e, coordinates[a] ?? 0);
+			}
+			const tupleEnd = serialized + size;
+			if (scalar !== 0) {
+				let at = serialized;
+				let points = sharedList;
+				if ((index & 8192) !== 0) [points, at] = readPoints(data, at);
+				const count = points === void 0 ? allPoints : points.length;
+				const [xs] = readDeltas(data, at, count);
+				const deltaOf = (point) => {
+					if (points === void 0) return xs[point] ?? 0;
+					const k = points.indexOf(point);
+					return k < 0 ? 0 : xs[k];
+				};
+				left += scalar * deltaOf(first);
+				right += scalar * deltaOf(first + 1);
+			}
+			serialized = tupleEnd;
+		}
+		const delta = right - left;
+		result[glyph] = deltas === "round" ? Math.sign(delta) * Math.round(Math.abs(delta)) : delta;
+	}
+	return result;
+}
+// src/fonts/indic.ts
+/** The OpenType script tags that use the Indic shaper in this model. */
+const indicScripts = ["deva"];
+const X = 0;
+const C = 1;
+const V = 2;
+const N = 3;
+const H = 4;
+const ZWNJ = 5;
+const ZWJ = 6;
+const M = 7;
+const SM = 8;
+const A = 9;
+const PLACEHOLDER = 10;
+const DOTTEDCIRCLE = 11;
+const RS = 12;
+const MPST = 13;
+const REPHA = 14;
+const RA = 15;
+const CM = 16;
+const SYMBOL = 17;
+const CS = 18;
+const SMPST = 57;
+const START = 0;
+const RA_TO_BECOME_REPH = 1;
+const PRE_M = 2;
+const PRE_C = 3;
+const BASE_C = 4;
+const BELOW_C = 8;
+const AFTER_SUB = 9;
+const POST_C = 11;
+const SMVD = 13;
+const END = 14;
+const CONSONANT_SYLLABLE = 0;
+const VOWEL_SYLLABLE = 1;
+const STANDALONE_CLUSTER = 2;
+const SYMBOL_CLUSTER = 3;
+const BROKEN_CLUSTER = 4;
+const NON_INDIC_CLUSTER = 5;
+/**
+* The categories and positions of the Indic table of HarfBuzz for the characters that Devanagari text uses. Each group of
+* four has the first code point, the last code point, the category and the position. Another code point has the category
+* `X` and the position `END`.
+*/
+const indicTable = [
+	45,
+	45,
+	PLACEHOLDER,
+	BASE_C,
+	48,
+	57,
+	PLACEHOLDER,
+	BASE_C,
+	160,
+	160,
+	PLACEHOLDER,
+	BASE_C,
+	178,
+	179,
+	SMPST,
+	SMVD,
+	215,
+	215,
+	PLACEHOLDER,
+	BASE_C,
+	2304,
+	2307,
+	SM,
+	SMVD,
+	2308,
+	2324,
+	V,
+	BASE_C,
+	2325,
+	2351,
+	C,
+	BASE_C,
+	2352,
+	2352,
+	RA,
+	BASE_C,
+	2353,
+	2361,
+	C,
+	BASE_C,
+	2362,
+	2363,
+	M,
+	AFTER_SUB,
+	2364,
+	2364,
+	N,
+	END,
+	2365,
+	2365,
+	SYMBOL,
+	SMVD,
+	2366,
+	2366,
+	M,
+	AFTER_SUB,
+	2367,
+	2367,
+	M,
+	PRE_M,
+	2368,
+	2380,
+	M,
+	AFTER_SUB,
+	2381,
+	2381,
+	H,
+	BELOW_C,
+	2382,
+	2382,
+	M,
+	PRE_M,
+	2383,
+	2383,
+	M,
+	AFTER_SUB,
+	2385,
+	2386,
+	A,
+	SMVD,
+	2387,
+	2388,
+	SM,
+	SMVD,
+	2389,
+	2391,
+	M,
+	AFTER_SUB,
+	2392,
+	2399,
+	C,
+	BASE_C,
+	2400,
+	2401,
+	V,
+	BASE_C,
+	2402,
+	2403,
+	M,
+	AFTER_SUB,
+	2406,
+	2415,
+	PLACEHOLDER,
+	BASE_C,
+	2418,
+	2423,
+	V,
+	BASE_C,
+	2424,
+	2431,
+	C,
+	BASE_C,
+	7376,
+	7378,
+	A,
+	SMVD,
+	7380,
+	7400,
+	A,
+	SMVD,
+	7401,
+	7404,
+	SYMBOL,
+	SMVD,
+	7405,
+	7405,
+	A,
+	SMVD,
+	7406,
+	7409,
+	SYMBOL,
+	SMVD,
+	7410,
+	7411,
+	C,
+	BASE_C,
+	7412,
+	7412,
+	A,
+	SMVD,
+	7413,
+	7414,
+	CS,
+	BASE_C,
+	7415,
+	7417,
+	A,
+	SMVD,
+	7418,
+	7418,
+	PLACEHOLDER,
+	BASE_C,
+	8204,
+	8204,
+	ZWNJ,
+	END,
+	8205,
+	8205,
+	ZWJ,
+	END,
+	8208,
+	8213,
+	PLACEHOLDER,
+	BASE_C,
+	8226,
+	8226,
+	PLACEHOLDER,
+	BASE_C,
+	8308,
+	8308,
+	SMPST,
+	SMVD,
+	8322,
+	8324,
+	SMPST,
+	SMVD,
+	9676,
+	9676,
+	DOTTEDCIRCLE,
+	BASE_C,
+	43232,
+	43249,
+	A,
+	SMVD,
+	43250,
+	43255,
+	SYMBOL,
+	SMVD,
+	43262,
+	43262,
+	V,
+	BASE_C,
+	43263,
+	43263,
+	M,
+	AFTER_SUB
+];
+/** This function gives the category and the position of a code point. */
+function indicProperties(codePoint) {
+	let low = 0;
+	let high = indicTable.length / 4 - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		if (codePoint < indicTable[middle * 4]) high = middle - 1;
+		else if (codePoint > indicTable[middle * 4 + 1]) low = middle + 1;
+		else return [indicTable[middle * 4 + 2], indicTable[middle * 4 + 3]];
+	}
+	return [X, END];
+}
+/**
+* The canonical combining classes of the marks of the Devanagari blocks that are not 0. The normalization uses them to
+* sort the marks and to block a composition. A mark of another block has the class 0 in this model.
+*/
+const combiningClasses = [
+	2364,
+	2364,
+	7,
+	2381,
+	2381,
+	9,
+	2385,
+	2385,
+	230,
+	2386,
+	2386,
+	220,
+	2387,
+	2388,
+	230,
+	7376,
+	7378,
+	230,
+	7380,
+	7380,
+	1,
+	7381,
+	7385,
+	220,
+	7386,
+	7387,
+	230,
+	7388,
+	7391,
+	220,
+	7392,
+	7392,
+	230,
+	7394,
+	7400,
+	1,
+	7405,
+	7405,
+	220,
+	7412,
+	7412,
+	230,
+	7416,
+	7417,
+	230,
+	43232,
+	43249,
+	230
+];
+function combiningClass(codePoint) {
+	for (let i = 0; i < combiningClasses.length; i += 3) if (codePoint >= combiningClasses[i] && codePoint <= combiningClasses[i + 1]) return combiningClasses[i + 2];
+	return 0;
+}
+const unicodeMark = /\p{M}/u;
+/** The general categories from `FORMAT` to `NON_SPACING_MARK` of HarfBuzz: a letter, a mark, or a format or other code point. */
+const letterOrMark = /[\p{L}\p{M}\p{Cf}\p{Cn}\p{Co}\p{Cs}]/u;
+function isMark(codePoint) {
+	return unicodeMark.test(String.fromCodePoint(codePoint));
+}
+/**
+* This function inserts a dotted circle in each vowel sequence of Devanagari that looks like another vowel, as
+* `_hb_preprocess_text_vowel_constraints` does.
+*/
+function vowelConstraints(codePoints) {
+	const out = [];
+	let i = 0;
+	while (i + 1 < codePoints.length) {
+		const first = codePoints[i];
+		const second = codePoints[i + 1];
+		let matched = false;
+		if (first === 2309) matched = [
+			2362,
+			2363,
+			2366,
+			2373,
+			2374,
+			2377,
+			2378,
+			2379,
+			2380,
+			2383,
+			2390,
+			2391
+		].includes(second);
+		else if (first === 2310) matched = [
+			2362,
+			2373,
+			2374,
+			2375,
+			2376
+		].includes(second);
+		else if (first === 2313) matched = second === 2369;
+		else if (first === 2319) matched = [
+			2373,
+			2374,
+			2375
+		].includes(second);
+		else if (first === 2352 && second === 2381 && codePoints[i + 2] === 2311) {
+			out.push(codePoints[i++]);
+			matched = true;
+		}
+		out.push(codePoints[i++]);
+		if (matched) out.push(9676, codePoints[i++]);
+	}
+	while (i < codePoints.length) out.push(codePoints[i++]);
+	return out;
+}
+/**
+* This function normalizes the code points as HarfBuzz does in the mode `COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT`. It
+* decomposes each character that has a canonical decomposition when the font has the glyphs of its parts. The letter
+* U+0931 does not decompose. A text with a mark after its first character then gets more steps. The function sorts the
+* marks, and composes each mark with its starter again when the font has the glyph of the composite.
+*/
+function normalize(codePoints, hasGlyph) {
+	const allSimple = !codePoints.some((codePoint, i) => i > 0 && isMark(codePoint));
+	const decomposed = [];
+	for (const codePoint of codePoints) {
+		const parts = codePoint === 2353 ? [codePoint] : [...String.fromCodePoint(codePoint).normalize("NFD")].map((part) => part.codePointAt(0));
+		if (parts.length > 1 || parts[0] !== codePoint) {
+			if (parts.every(hasGlyph)) {
+				decomposed.push(...parts);
+				continue;
+			}
+		}
+		decomposed.push(codePoint);
+	}
+	if (allSimple) return decomposed;
+	for (let i = 1; i < decomposed.length; i++) for (let j = i; j > 0; j--) {
+		const before = combiningClass(decomposed[j - 1]);
+		const after = combiningClass(decomposed[j]);
+		if (after === 0 || before <= after) break;
+		[decomposed[j - 1], decomposed[j]] = [decomposed[j], decomposed[j - 1]];
+	}
+	const out = decomposed.slice(0, 1);
+	let starter = 0;
+	for (let i = 1; i < decomposed.length; i++) {
+		const codePoint = decomposed[i];
+		if (isMark(codePoint) && (starter === out.length - 1 || combiningClass(out[out.length - 1]) < combiningClass(codePoint))) {
+			const composed = compose(out[starter], codePoint);
+			if (composed !== void 0 && hasGlyph(composed)) {
+				out[starter] = composed;
+				continue;
+			}
+		}
+		out.push(codePoint);
+		if (combiningClass(codePoint) === 0) starter = out.length - 1;
+	}
+	return out;
+}
+/** This function gives the canonical composite of two code points, or `undefined`. A mark does not compose with a mark. */
+function compose(first, second) {
+	if (isMark(first)) return void 0;
+	const [single, ...rest] = [...[(String.fromCodePoint(first) + String.fromCodePoint(second)).normalize("NFC")][0]];
+	return rest.length === 0 && single !== void 0 ? single.codePointAt(0) : void 0;
+}
+const letters = /* @__PURE__ */ new Map([
+	[X, "x"],
+	[C, "c"],
+	[V, "v"],
+	[N, "n"],
+	[H, "h"],
+	[ZWNJ, "w"],
+	[ZWJ, "j"],
+	[M, "m"],
+	[SM, "s"],
+	[A, "a"],
+	[PLACEHOLDER, "p"],
+	[DOTTEDCIRCLE, "d"],
+	[RS, "r"],
+	[MPST, "q"],
+	[REPHA, "f"],
+	[RA, "R"],
+	[CM, "k"],
+	[SYMBOL, "y"],
+	[CS, "S"],
+	[SMPST, "t"]
+]);
+const c = "[cR]";
+const n = "(?:w?r)?(?:nn?)?";
+const z = "[wj]";
+const reph = "(?:Rh|f)";
+const sm = "[st]";
+const cn = `${c}j?${n}`;
+const matraGroup = `${z}*(?:m|${sm}?q)n?h?`;
+const syllableTail = `(?:${z}?${sm}${sm}?w?)?a*`;
+const halantGroup = `(?:${z}?h(?:jn?)?)`;
+const complexSyllableTail = `(?:${halantGroup}${cn})*k?(?:${`(?:${halantGroup}|hw)`}|(?:${matraGroup})*)${syllableTail}`;
+/** The rules of the machine in the order of HarfBuzz. A tie of two lengths goes to the first rule. */
+const machine = [
+	[`[fS]?${cn}${complexSyllableTail}`, CONSONANT_SYLLABLE],
+	[`${reph}?v${n}(?:j|${complexSyllableTail})`, VOWEL_SYLLABLE],
+	[`(?:[fS]?p|${reph}?d)${n}${complexSyllableTail}`, STANDALONE_CLUSTER],
+	[`yn?${syllableTail}`, SYMBOL_CLUSTER],
+	["t", NON_INDIC_CLUSTER],
+	[`${reph}?${n}${complexSyllableTail}`, BROKEN_CLUSTER],
+	["[^]", NON_INDIC_CLUSTER]
+].map(([rule, type]) => [new RegExp(`^(?:${rule})$`), type]);
+/**
+* This function divides the glyphs into syllables, as the machine of HarfBuzz does. At each position, it takes the
+* longest match of the rules. Each glyph gets the syllable byte. Its high 4 bits are a serial number from 1 to 15, and
+* its low 4 bits are the type. The function tells if a syllable is a broken cluster.
+*/
+function findSyllables(infos) {
+	const text = infos.map((info) => letters.get(info.category) ?? "x").join("");
+	let serial = 1;
+	let broken = false;
+	let at = 0;
+	while (at < text.length) {
+		const next = text.indexOf("x", at + 1);
+		let length = 1;
+		let type = NON_INDIC_CLUSTER;
+		search: for (let end = next < 0 ? text.length : next; end > at; end--) {
+			const piece = text.slice(at, end);
+			for (const [rule, kind] of machine) if (rule.test(piece)) {
+				length = end - at;
+				type = kind;
+				break search;
+			}
+		}
+		if (type === BROKEN_CLUSTER) broken = true;
+		for (let i = at; i < at + length; i++) infos[i].syllable = serial << 4 | type;
+		serial = serial === 15 ? 1 : serial + 1;
+		at += length;
+	}
+	return broken;
+}
+/** It is true when the glyph made no ligature and its category is one of `categories`. A ligature has no category. */
+function isOneOf(info, categories) {
+	return (info.props & 32) === 0 && categories.includes(info.category);
+}
+const consonants = [
+	C,
+	CS,
+	RA,
+	CM,
+	V,
+	PLACEHOLDER,
+	DOTTEDCIRCLE
+];
+const joiners = [ZWJ, ZWNJ];
+const isConsonant = (info) => isOneOf(info, consonants);
+const isJoiner = (info) => isOneOf(info, joiners);
+const isHalant = (info) => isOneOf(info, [H]);
+const ligatedAndDidntMultiply = (info) => (info.props & 96) === 32;
+/** The basic features, in the order of their stages before the final reordering. The value is true for a global feature. */
+const basicFeatures = [
+	["nukt", true],
+	["akhn", true],
+	["rphf", false],
+	["rkrf", true],
+	["pref", false],
+	["blwf", false],
+	["abvf", false],
+	["half", false],
+	["pstf", false],
+	["vatu", true],
+	["cjct", true]
+];
+/** The features of the last stage, after the final reordering. They match only in a syllable. */
+const finalFeatures = [
+	"init",
+	"pres",
+	"abvs",
+	"blws",
+	"psts",
+	"haln"
+];
+/** The mask bit of the global features. Each glyph has it. */
+const GLOBAL = 1;
+/** The mask bits of the features that apply only to some glyphs of a syllable. */
+const featureBits = /* @__PURE__ */ new Map([
+	["rphf", 2],
+	["pref", 4],
+	["blwf", 8],
+	["abvf", 16],
+	["half", 32],
+	["pstf", 64],
+	["init", 128]
+]);
+/** This function moves the glyph at `from` to `to`. The glyphs between them move by one position. */
+function move(run, from, to) {
+	const [glyph] = run.glyphs.splice(from, 1);
+	const [info] = run.infos.splice(from, 1);
+	run.glyphs.splice(to, 0, glyph);
+	run.infos.splice(to, 0, info);
+}
+function reverse(run, start, end) {
+	run.glyphs.splice(start, end - start, ...run.glyphs.slice(start, end).reverse());
+	run.infos.splice(start, end - start, ...run.infos.slice(start, end).reverse());
+}
+/** This function gives the ranges of the syllables, as `foreach_syllable` of HarfBuzz. */
+function syllables(infos) {
+	const ranges = [];
+	let start = 0;
+	for (let i = 1; i <= infos.length; i++) if (i === infos.length || infos[i].syllable !== infos[start].syllable) {
+		ranges.push([start, i]);
+		start = i;
+	}
+	return infos.length === 0 ? [] : ranges;
+}
+/**
+* This function makes the function that gives the glyphs of a word with the Indic shaper. The features `features` are the
+* features of the page. The shaper applies `locl` and `ccmp` before it reorders the syllables, and the other features of
+* the page after its own features. It does not apply `liga`.
+*/
+function indicShaper(font, script, features) {
+	const lookupsOf = (tags) => font.substitutions(script, tags);
+	const maskOf = (tag) => lookupsOf([tag]).length === 0 ? 0 : featureBits.get(tag) ?? GLOBAL;
+	const [rphfMask, prefMask, blwfMask, abvfMask, halfMask, pstfMask, initMask] = [
+		"rphf",
+		"pref",
+		"blwf",
+		"abvf",
+		"half",
+		"pstf",
+		"init"
+	].map(maskOf);
+	const would = (tag, glyphs) => lookupsOf([tag]).some((lookup) => lookup.wouldApply(glyphs));
+	const virama = font.glyph(2381);
+	const dottedCircle = font.glyph(9676);
+	const positions = /* @__PURE__ */ new Map();
+	/** This function gives the position of a consonant from the below-base, post-base and pre-base forms of the font. */
+	const consonantPosition = (consonant) => {
+		let position = positions.get(consonant);
+		if (position === void 0) {
+			const before = [virama, consonant];
+			const after = [consonant, virama];
+			const either = (tag) => would(tag, before) || would(tag, after);
+			position = either("blwf") || either("vatu") ? BELOW_C : either("pstf") || either("pref") ? POST_C : BASE_C;
+			positions.set(consonant, position);
+		}
+		return position;
+	};
+	const first = lookupsOf(["locl", "ccmp"]);
+	const basic = basicFeatures.map(([tag, global]) => ({
+		lookups: lookupsOf([tag]),
+		mask: global ? GLOBAL : featureBits.get(tag)
+	}));
+	const extra = features.filter((tag) => ![
+		"ccmp",
+		"locl",
+		"liga"
+	].includes(tag) && !finalFeatures.includes(tag));
+	const last = lookupsOf([...finalFeatures, ...extra]).map((lookup) => ({
+		lookup,
+		mask: lookup.features.reduce((mask, tag) => mask | (tag === "init" ? initMask : GLOBAL), 0),
+		perSyllable: lookup.features.some((tag) => finalFeatures.includes(tag))
+	}));
+	/** This function reorders one syllable before the basic features, and gives the masks of its glyphs. */
+	const initialReordering = (run, start, end) => {
+		const { glyphs, infos } = run;
+		let base = end;
+		let hasReph = false;
+		let limit = start;
+		if (rphfMask !== 0 && start + 3 <= end && !isJoiner(infos[start + 2]) && would("rphf", [glyphs[start], glyphs[start + 1]])) {
+			limit += 2;
+			while (limit < end && isJoiner(infos[limit])) limit++;
+			base = start;
+			hasReph = true;
+		}
+		let seenBelow = false;
+		for (let i = end - 1; i >= limit; i--) {
+			const info = infos[i];
+			if (isConsonant(info)) {
+				base = i;
+				if (info.position !== BELOW_C && (info.position !== POST_C || seenBelow)) break;
+				if (info.position === BELOW_C) seenBelow = true;
+			} else if (start < i && info.category === ZWJ && infos[i - 1].category === H) break;
+		}
+		if (hasReph && base === start && limit - base <= 2) hasReph = false;
+		for (let i = start; i < base; i++) infos[i].position = Math.min(PRE_C, infos[i].position);
+		if (base < end) infos[base].position = BASE_C;
+		if (hasReph) infos[start].position = RA_TO_BECOME_REPH;
+		let lastPosition = START;
+		for (let i = start; i < end; i++) {
+			const info = infos[i];
+			if ([
+				ZWJ,
+				ZWNJ,
+				N,
+				RS,
+				CM,
+				H
+			].includes(info.category)) {
+				info.position = lastPosition;
+				if (info.category === H && info.position === PRE_M) {
+					for (let j = i; j > start; j--) if (infos[j - 1].position !== PRE_M) {
+						info.position = infos[j - 1].position;
+						break;
+					}
+				}
+			} else if (info.position !== SMVD) {
+				if (info.category === MPST && i > start && infos[i - 1].category === SM) infos[i - 1].position = info.position;
+				lastPosition = info.position;
+			}
+		}
+		let previous = base;
+		for (let i = base + 1; i < end; i++) if (isConsonant(infos[i])) {
+			for (let j = previous + 1; j < i; j++) if (infos[j].position < SMVD) infos[j].position = infos[i].position;
+			previous = i;
+		} else if (infos[i].category === M || infos[i].category === MPST) previous = i;
+		glyphs.slice(start, end).map((glyph, k) => ({
+			glyph,
+			info: infos[start + k]
+		})).sort((a, b) => a.info.position - b.info.position).forEach(({ glyph, info }, k) => {
+			glyphs[start + k] = glyph;
+			infos[start + k] = info;
+		});
+		base = end;
+		let firstLeftMatra = end;
+		let lastLeftMatra = end;
+		for (let i = start; i < end; i++) {
+			if (infos[i].position === BASE_C) {
+				base = i;
+				break;
+			}
+			if (infos[i].position === PRE_M) {
+				if (firstLeftMatra === end) firstLeftMatra = i;
+				lastLeftMatra = i;
+			}
+		}
+		if (firstLeftMatra < lastLeftMatra) {
+			reverse(run, firstLeftMatra, lastLeftMatra + 1);
+			let i = firstLeftMatra;
+			for (let j = i; j <= lastLeftMatra; j++) if (infos[j].category === M || infos[j].category === MPST) {
+				reverse(run, i, j + 1);
+				i = j + 1;
+			}
+		}
+		for (let i = start; i < end && infos[i].position === RA_TO_BECOME_REPH; i++) infos[i].mask |= rphfMask;
+		for (let i = start; i < base; i++) infos[i].mask |= halfMask | blwfMask;
+		for (let i = base + 1; i < end; i++) infos[i].mask |= blwfMask | abvfMask | pstfMask;
+		if (prefMask !== 0 && base + 2 < end) {
+			for (let i = base + 1; i + 1 < end; i++) if (would("pref", [glyphs[i], glyphs[i + 1]])) {
+				infos[i].mask |= prefMask;
+				infos[i + 1].mask |= prefMask;
+				break;
+			}
+		}
+		for (let i = start + 1; i < end; i++) {
+			if (!isJoiner(infos[i]) || infos[i].category !== ZWNJ) continue;
+			let j = i;
+			do {
+				j--;
+				infos[j].mask &= ~halfMask;
+			} while (j > start && !isConsonant(infos[j]));
+		}
+	};
+	/** This function moves the pre-base matra and the reph of one syllable after the basic features. */
+	const finalReordering = (run, start, end) => {
+		const { glyphs, infos } = run;
+		for (let i = start; i < end; i++) if (virama !== 0 && glyphs[i] === virama && (infos[i].props & 96) === 96) {
+			infos[i].category = H;
+			infos[i].props &= -97;
+		}
+		let tryPref = prefMask !== 0;
+		let base = start;
+		for (; base < end; base++) {
+			if (infos[base].position < BASE_C) continue;
+			if (tryPref && base + 1 < end) {
+				for (let i = base + 1; i < end; i++) {
+					if ((infos[i].mask & prefMask) === 0) continue;
+					if (!((infos[i].props & 16) !== 0 && ligatedAndDidntMultiply(infos[i]))) {
+						base = i;
+						while (base < end && isHalant(infos[base])) base++;
+						if (base < end) infos[base].position = BASE_C;
+						tryPref = false;
+					}
+					break;
+				}
+				if (base === end) break;
+			}
+			if (start < base && infos[base].position > BASE_C) base--;
+			break;
+		}
+		if (base === end && start < base && isOneOf(infos[base - 1], [ZWJ])) base--;
+		if (base < end) while (start < base && isOneOf(infos[base], [N, H])) base--;
+		if (start + 1 < end && start < base) {
+			let newPosition = base === end ? base - 2 : base - 1;
+			for (;;) {
+				while (newPosition > start && !isOneOf(infos[newPosition], [
+					M,
+					MPST,
+					H
+				])) newPosition--;
+				if (isHalant(infos[newPosition]) && infos[newPosition].position !== PRE_M) {
+					if (newPosition + 1 < end && infos[newPosition + 1].category === ZWJ && newPosition > start) {
+						newPosition--;
+						continue;
+					}
+				} else newPosition = start;
+				break;
+			}
+			if (start < newPosition && infos[newPosition].position !== PRE_M) for (let i = newPosition; i > start; i--) {
+				if (infos[i - 1].position !== PRE_M) continue;
+				const oldPosition = i - 1;
+				if (oldPosition < base && base <= newPosition) base--;
+				move(run, oldPosition, newPosition);
+				newPosition--;
+			}
+		}
+		if (start + 1 < end && infos[start].position === RA_TO_BECOME_REPH && infos[start].category === REPHA !== ligatedAndDidntMultiply(infos[start])) {
+			let newPosition = start + 1;
+			while (newPosition < base && !isHalant(infos[newPosition])) newPosition++;
+			if (newPosition < base && isHalant(infos[newPosition])) {
+				if (newPosition + 1 < base && isJoiner(infos[newPosition + 1])) newPosition++;
+			} else {
+				newPosition = end - 1;
+				while (newPosition > start && infos[newPosition].position === SMVD) newPosition--;
+				if (isHalant(infos[newPosition])) {
+					for (let i = base + 1; i < newPosition; i++) if (infos[i].category === M || infos[i].category === MPST) newPosition--;
+				}
+			}
+			move(run, start, newPosition);
+			if (start < base && base <= newPosition) base--;
+		}
+		if (tryPref && base + 1 < end) for (let i = base + 1; i < end; i++) {
+			if ((infos[i].mask & prefMask) === 0) continue;
+			if (ligatedAndDidntMultiply(infos[i])) {
+				let newPosition = base;
+				while (newPosition > start && !isOneOf(infos[newPosition - 1], [
+					M,
+					MPST,
+					H
+				])) newPosition--;
+				if (newPosition > start && isHalant(infos[newPosition - 1]) && newPosition < end && isJoiner(infos[newPosition])) newPosition++;
+				move(run, i, newPosition);
+				if (newPosition <= base && base < i) base++;
+			}
+			break;
+		}
+		if (infos[start].position === PRE_M && (start === 0 || !letterOrMark.test(String.fromCodePoint(infos[start - 1].codePoint)))) infos[start].mask |= initMask;
+	};
+	return (word) => {
+		const codePoints = normalize(vowelConstraints([...word].map((character) => character.codePointAt(0))), (codePoint) => font.glyph(codePoint) !== 0);
+		const run = {
+			glyphs: codePoints.map((codePoint) => font.glyph(codePoint)),
+			infos: []
+		};
+		for (const codePoint of codePoints) {
+			const [category, position] = indicProperties(codePoint);
+			run.infos.push({
+				mask: GLOBAL,
+				syllable: 0,
+				props: 0,
+				category,
+				position,
+				codePoint
+			});
+		}
+		const broken = findSyllables(run.infos);
+		for (const lookup of first) lookup.applyInfos(run.glyphs, run.infos, GLOBAL, true);
+		if (virama !== 0) {
+			for (let i = 0; i < run.infos.length; i++) if (run.infos[i].position === BASE_C) run.infos[i].position = consonantPosition(run.glyphs[i]);
+		}
+		if (broken && dottedCircle !== 0) for (let i = run.infos.length - 1; i >= 0; i--) {
+			const info = run.infos[i];
+			if ((info.syllable & 15) !== BROKEN_CLUSTER || i > 0 && run.infos[i - 1].syllable === info.syllable) continue;
+			run.glyphs.splice(i, 0, dottedCircle);
+			run.infos.splice(i, 0, {
+				mask: info.mask,
+				syllable: info.syllable,
+				props: 0,
+				category: DOTTEDCIRCLE,
+				position: END,
+				codePoint: 9676
+			});
+		}
+		for (const [start, end] of syllables(run.infos)) {
+			const type = run.infos[start].syllable & 15;
+			if (type !== SYMBOL_CLUSTER && type !== NON_INDIC_CLUSTER) initialReordering(run, start, end);
+		}
+		for (const { lookups, mask } of basic) for (const lookup of lookups) lookup.applyInfos(run.glyphs, run.infos, mask, true);
+		for (const [start, end] of syllables(run.infos)) finalReordering(run, start, end);
+		for (const { lookup, mask, perSyllable } of last) lookup.applyInfos(run.glyphs, run.infos, mask, perSyllable);
+		return run.glyphs;
+	};
+}
+// src/fonts/joining.ts
+/** The forms in the order of the features of the shaper. The index of a form gives its bit in a feature mask. */
+const joiningFeatures = [
+	"isol",
+	"fina",
+	"fin2",
+	"fin3",
+	"medi",
+	"med2",
+	"init"
+];
+/** The OpenType script tags that use the joining of the Arabic shaper in this model. */
+const joiningScripts = ["arab", "syrc"];
+const U = 0;
+const R = 2;
+const D = 3;
+const ALAPH = 4;
+const DALATH_RISH = 5;
+/** The joining type T: a transparent character, for example a mark. The state machine does not see it. */
+const T = 6;
+/**
+* The joining types of `ArabicShaping.txt`. Each triple has the first code point, the last code point and the type.
+* The type `C` (join causing) is `D` here, as in HarfBuzz. A code point that is not in the table has the type `U`.
+* When its general category is `Mn`, `Me` or `Cf`, it has the type `T`.
+*/
+const joiningTable = [
+	1536,
+	1541,
+	U,
+	1544,
+	1544,
+	U,
+	1547,
+	1547,
+	U,
+	1568,
+	1568,
+	D,
+	1569,
+	1569,
+	U,
+	1570,
+	1573,
+	R,
+	1574,
+	1574,
+	D,
+	1575,
+	1575,
+	R,
+	1576,
+	1576,
+	D,
+	1577,
+	1577,
+	R,
+	1578,
+	1582,
+	D,
+	1583,
+	1586,
+	R,
+	1587,
+	1599,
+	D,
+	1600,
+	1600,
+	D,
+	1601,
+	1607,
+	D,
+	1608,
+	1608,
+	R,
+	1609,
+	1610,
+	D,
+	1646,
+	1647,
+	D,
+	1649,
+	1651,
+	R,
+	1652,
+	1652,
+	U,
+	1653,
+	1655,
+	R,
+	1656,
+	1671,
+	D,
+	1672,
+	1689,
+	R,
+	1690,
+	1727,
+	D,
+	1728,
+	1728,
+	R,
+	1729,
+	1730,
+	D,
+	1731,
+	1739,
+	R,
+	1740,
+	1740,
+	D,
+	1741,
+	1741,
+	R,
+	1742,
+	1742,
+	D,
+	1743,
+	1743,
+	R,
+	1744,
+	1745,
+	D,
+	1746,
+	1747,
+	R,
+	1749,
+	1749,
+	R,
+	1757,
+	1757,
+	U,
+	1774,
+	1775,
+	R,
+	1786,
+	1788,
+	D,
+	1791,
+	1791,
+	D,
+	1807,
+	1807,
+	T,
+	1808,
+	1808,
+	ALAPH,
+	1810,
+	1812,
+	D,
+	1813,
+	1814,
+	DALATH_RISH,
+	1815,
+	1817,
+	R,
+	1818,
+	1821,
+	D,
+	1822,
+	1822,
+	R,
+	1823,
+	1831,
+	D,
+	1832,
+	1832,
+	R,
+	1833,
+	1833,
+	D,
+	1834,
+	1834,
+	DALATH_RISH,
+	1835,
+	1835,
+	D,
+	1836,
+	1836,
+	R,
+	1837,
+	1838,
+	D,
+	1839,
+	1839,
+	DALATH_RISH,
+	1869,
+	1869,
+	R,
+	1870,
+	1880,
+	D,
+	1881,
+	1883,
+	R,
+	1884,
+	1898,
+	D,
+	1899,
+	1900,
+	R,
+	1901,
+	1904,
+	D,
+	1905,
+	1905,
+	R,
+	1906,
+	1906,
+	D,
+	1907,
+	1908,
+	R,
+	1909,
+	1911,
+	D,
+	1912,
+	1913,
+	R,
+	1914,
+	1919,
+	D,
+	1994,
+	2026,
+	D,
+	2042,
+	2042,
+	D,
+	2112,
+	2112,
+	R,
+	2113,
+	2117,
+	D,
+	2118,
+	2119,
+	R,
+	2120,
+	2120,
+	D,
+	2121,
+	2121,
+	R,
+	2122,
+	2131,
+	D,
+	2132,
+	2132,
+	R,
+	2133,
+	2133,
+	D,
+	2134,
+	2136,
+	R,
+	2144,
+	2144,
+	D,
+	2145,
+	2145,
+	U,
+	2146,
+	2149,
+	D,
+	2150,
+	2150,
+	U,
+	2151,
+	2151,
+	R,
+	2152,
+	2152,
+	D,
+	2153,
+	2154,
+	R,
+	2160,
+	2178,
+	R,
+	2179,
+	2181,
+	D,
+	2182,
+	2182,
+	D,
+	2183,
+	2184,
+	U,
+	2185,
+	2189,
+	D,
+	2190,
+	2190,
+	R,
+	2191,
+	2191,
+	D,
+	2192,
+	2193,
+	U,
+	2208,
+	2217,
+	D,
+	2218,
+	2220,
+	R,
+	2221,
+	2221,
+	U,
+	2222,
+	2222,
+	R,
+	2223,
+	2224,
+	D,
+	2225,
+	2226,
+	R,
+	2227,
+	2232,
+	D,
+	2233,
+	2233,
+	R,
+	2234,
+	2248,
+	D,
+	2274,
+	2274,
+	U,
+	8204,
+	8204,
+	U,
+	8205,
+	8205,
+	D
+];
+const transparent = /[\p{Mn}\p{Me}\p{Cf}]/u;
+/** This function gives the joining type of a code point: a column of the state machine, or `T`. */
+function joiningType(codePoint) {
+	let low = 0;
+	let high = joiningTable.length / 3 - 1;
+	while (low <= high) {
+		const middle = low + high >> 1;
+		if (codePoint < joiningTable[middle * 3]) high = middle - 1;
+		else if (codePoint > joiningTable[middle * 3 + 1]) low = middle + 1;
+		else return joiningTable[middle * 3 + 2];
+	}
+	return transparent.test(String.fromCodePoint(codePoint)) ? T : U;
+}
+const ISOL = 0;
+const FINA = 1;
+const FIN2 = 2;
+const FIN3 = 3;
+const MEDI = 4;
+const MED2 = 5;
+const INIT = 6;
+const NONE = 7;
+/**
+* The state machine of `arabic_state_table` of HarfBuzz. Each row is a state, with one entry for each column. An entry
+* has the action for the previous letter, the action for the current letter and the next state.
+*/
+const states = [
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			ISOL,
+			1
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			ISOL,
+			1
+		],
+		[
+			NONE,
+			ISOL,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			ISOL,
+			1
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			FIN2,
+			5
+		],
+		[
+			NONE,
+			ISOL,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			INIT,
+			FINA,
+			1
+		],
+		[
+			INIT,
+			FINA,
+			3
+		],
+		[
+			INIT,
+			FINA,
+			4
+		],
+		[
+			INIT,
+			FINA,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			MEDI,
+			FINA,
+			1
+		],
+		[
+			MEDI,
+			FINA,
+			3
+		],
+		[
+			MEDI,
+			FINA,
+			4
+		],
+		[
+			MEDI,
+			FINA,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			MED2,
+			ISOL,
+			1
+		],
+		[
+			MED2,
+			ISOL,
+			2
+		],
+		[
+			MED2,
+			FIN2,
+			5
+		],
+		[
+			MED2,
+			ISOL,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			ISOL,
+			ISOL,
+			1
+		],
+		[
+			ISOL,
+			ISOL,
+			2
+		],
+		[
+			ISOL,
+			FIN2,
+			5
+		],
+		[
+			ISOL,
+			ISOL,
+			6
+		]
+	],
+	[
+		[
+			NONE,
+			NONE,
+			0
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			ISOL,
+			1
+		],
+		[
+			NONE,
+			ISOL,
+			2
+		],
+		[
+			NONE,
+			FIN3,
+			5
+		],
+		[
+			NONE,
+			ISOL,
+			6
+		]
+	]
+];
+/**
+* This function gives the joining form of each code point of a text, in logical order. A transparent character, for
+* example a mark, and a character that does not join get `undefined`. The text before and after the code points is not
+* known, so the function sees it as a character of the type U.
+*/
+function joiningForms(codePoints) {
+	const actions = codePoints.map(() => NONE);
+	let previous = -1;
+	let state = 0;
+	codePoints.forEach((codePoint, i) => {
+		const type = joiningType(codePoint);
+		if (type === T) return;
+		const [previousAction, currentAction, next] = states[state][type];
+		if (previousAction !== NONE && previous >= 0) actions[previous] = previousAction;
+		actions[i] = currentAction;
+		previous = i;
+		state = next;
+	});
+	return actions.map((action) => joiningFeatures[action]);
+}
+/**
+* This function gives the stages of the Arabic shaper of HarfBuzz for a list of features. The stages are `ccmp` and
+* `locl`, then each joining form alone, then `rlig`, then `calt`, then the other features. When the font has `rclt`,
+* `calt` and the other features are one stage, as in HarfBuzz. The list `features` gives the features apart from the
+* joining forms, so a feature that is not in the list is not in a stage.
+*/
+function joiningStages(features, hasRclt) {
+	const take = (tags) => features.filter((tag) => tags.includes(tag));
+	const first = ["ccmp", "locl"];
+	const rest = features.filter((tag) => !first.includes(tag) && tag !== "rlig" && (hasRclt || tag !== "calt"));
+	const stages = [
+		{ features: take(first) },
+		...joiningFeatures.map((form) => ({
+			features: [form],
+			form
+		})),
+		{ features: take(["rlig"]) }
+	];
+	if (!hasRclt) stages.push({ features: take(["calt"]) });
+	stages.push({ features: rest });
+	return stages.filter((stage) => stage.features.length > 0);
+}
+// src/fonts/bidi.ts
+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 = /* @__PURE__ */ new Set([
+	44,
+	46,
+	47,
+	58,
+	160,
+	1548,
+	8239,
+	8260
+]);
+/** This function gives the bidi class of a character, from its code point, its script and its general category. */
+function bidiClass(character) {
+	const c = character.codePointAt(0);
+	if (nonSpacingMark.test(character)) return "NSM";
+	if (c >= 48 && c <= 57 || c >= 1776 && c <= 1785 || c === 178 || c === 179 || c === 185 || c >= 65296 && c <= 65305) return "EN";
+	if (c >= 1632 && c <= 1641 || c === 1643 || c === 1644) return "AN";
+	if (c === 43 || c === 45 || c === 8722) return "ES";
+	if (c === 35 || c === 37 || c === 176 || c === 8240 || currency.test(character)) return "ET";
+	if (commonSeparators.has(c)) return "CS";
+	if (c === 9 || c === 11 || c === 31) return "S";
+	if (c === 10 || c === 13 || c >= 28 && c <= 30 || c === 133 || c === 8233) return "B";
+	if (c === 32 || c === 12 || c >= 8192 && c <= 8202 || c === 8232 || c === 12288) 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) {
+	if (type === "L") return "L";
+	return type === "R" || type === "EN" || type === "AN" ? "R" : void 0;
+}
+/**
+* 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.
+*/
+function bidiLevels(text) {
+	const original = [...text].map(bidiClass);
+	const types = [...original];
+	const n = types.length;
+	for (let i = 0; i < n; i++) if (types[i] === "NSM") types[i] = i === 0 || types[i - 1] === "BN" ? "L" : types[i - 1];
+	let strong = "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";
+	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;
+	}
+	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;
+	}
+	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";
+	}
+	for (let i = 0; i < n; i++) {
+		if (strongDirection(types[i]) !== void 0) continue;
+		let end = i;
+		while (end < n && strongDirection(types[end]) === void 0) 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;
+	}
+	const levels = types.map((type) => type === "R" ? 1 : type === "AN" || type === "EN" ? 2 : 0);
+	const isSpace = (i) => 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.
+*/
+function visualOrder(items, levels) {
+	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]);
+}
+// src/fonts/words.ts
+/**
+* The words of the text of a canvas. Blink shapes the text of `fillText` and `measureText` one word at a time, so no GSUB
+* context and no pair kerning goes across two words. This module follows `NextWordEndIndex` of
+* `third_party/blink/renderer/platform/fonts/plain_text_node.cc` and the CJK table of `character_property_data.h`.
+* The Chromium Authors wrote these files under a BSD-style license.
+*/
+/** The single code points of the CJK table of Blink. */
+const cjkValues = /* @__PURE__ */ new Set([
+	711,
+	714,
+	715,
+	729,
+	8224,
+	8225,
+	8240,
+	8251,
+	8252,
+	8258,
+	8263,
+	8264,
+	8265,
+	8273,
+	8413,
+	8414,
+	8448,
+	8451,
+	8453,
+	8457,
+	8458,
+	8467,
+	8470,
+	8481,
+	8491,
+	8507,
+	8528,
+	8529,
+	8530,
+	8575,
+	8585,
+	8967,
+	8978,
+	9166,
+	9251,
+	9632,
+	9633,
+	9634,
+	9642,
+	9643,
+	9649,
+	9650,
+	9651,
+	9654,
+	9655,
+	9660,
+	9661,
+	9664,
+	9665,
+	9670,
+	9671,
+	9673,
+	9675,
+	9676,
+	9711,
+	9733,
+	9734,
+	9742,
+	9750,
+	9751,
+	9888,
+	10003,
+	10010,
+	10047,
+	10048,
+	10070,
+	10083,
+	11034,
+	65040,
+	65041,
+	65042,
+	65049,
+	65309,
+	127232,
+	127488,
+	127543,
+	127788,
+	127798,
+	127869,
+	128063,
+	128335,
+	129339,
+	129350
+]);
+/** The ranges of the CJK table of Blink, as pairs of the first and the last code point. */
+const cjkRanges = [
+	11904,
+	12255,
+	12736,
+	12783,
+	13312,
+	19903,
+	19968,
+	40959,
+	63744,
+	64255,
+	131072,
+	196607,
+	8534,
+	8538,
+	8544,
+	8555,
+	8560,
+	8571,
+	9150,
+	9164,
+	9312,
+	9362,
+	9372,
+	9471,
+	9678,
+	9683,
+	9698,
+	9702,
+	9728,
+	9731,
+	9824,
+	9839,
+	9842,
+	9853,
+	10102,
+	10111,
+	12272,
+	12333,
+	12337,
+	12591,
+	12688,
+	12735,
+	12800,
+	13311,
+	19904,
+	19967,
+	63584,
+	63586,
+	65072,
+	65135,
+	65280,
+	65292,
+	65294,
+	65306,
+	65311,
+	65519,
+	94176,
+	94207,
+	94208,
+	100351,
+	100352,
+	101119,
+	110592,
+	110847,
+	110848,
+	110895,
+	110960,
+	111359,
+	127248,
+	127273,
+	127280,
+	127305,
+	127312,
+	127337,
+	127344,
+	127369,
+	127490,
+	127513,
+	127515,
+	127534,
+	127536,
+	127537,
+	127547,
+	127567,
+	127570,
+	127743,
+	127777,
+	127786,
+	127892,
+	127903,
+	127949,
+	127950,
+	127956,
+	127967,
+	127985,
+	127986,
+	127989,
+	127991,
+	128253,
+	128254,
+	128318,
+	128330,
+	128360,
+	128371,
+	128374,
+	128377,
+	128379,
+	128399,
+	128401,
+	128404,
+	128407,
+	128419,
+	128421,
+	128487,
+	128489,
+	128506,
+	128592,
+	128639,
+	128710,
+	128715,
+	128717,
+	128719,
+	128723,
+	128724,
+	128729,
+	128731,
+	128736,
+	128746,
+	128749,
+	128755,
+	128765,
+	128767,
+	129280,
+	129291,
+	129737,
+	129740
+];
+const emojiPresentation = /\p{Emoji_Presentation}/u;
+const modifierLike = /[\p{M}\p{Lm}\p{Sk}]/u;
+const continuesEmoji = /[‍\p{Emoji_Component}\p{Extended_Pictographic}]/u;
+const commonOrInherited = /[\p{Script=Common}\p{Script=Inherited}]/u;
+/**
+* This function tells if Blink starts a CJK word at the code point `codePoint`. Blink also marks the pictographs of the
+* RGI emoji sequences. This function uses `Emoji_Presentation` for them, so some text-style pictographs are missing.
+*/
+function isCjkIdeographOrSymbol(codePoint) {
+	if (codePoint < 711) return false;
+	if (cjkValues.has(codePoint)) return true;
+	for (let i = 0; i < cjkRanges.length; i += 2) if (codePoint >= cjkRanges[i] && codePoint <= cjkRanges[i + 1]) return true;
+	return emojiPresentation.test(String.fromCodePoint(codePoint));
+}
+/** This function tells if Blink ends a word before the character `character`: a space, a tab or a zero width space. */
+function isDelimiter(character) {
+	return character === " " || character === "	" || character === "​";
+}
+/**
+* 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.
+*/
+function canvasWords(text) {
+	const characters = [...text];
+	const words = [];
+	let start = 0;
+	while (start < characters.length) {
+		const end = wordEnd(characters, start);
+		words.push(characters.slice(start, end).join(""));
+		start = end;
+	}
+	return words;
+}
+/**
+* This function gives the segments of the text of a canvas in the visual order. A segment is a word of `canvasWords`, or a
+* part of a word where the bidi level changes. Blink shapes each bidi run alone and adds the widths of the words in this order.
+*/
+function canvasSegments(text) {
+	const characters = [...text];
+	const levels = bidiLevels(text);
+	const segments = [];
+	const segmentLevels = [];
+	let at = 0;
+	for (const word of canvasWords(text)) {
+		const end = at + [...word].length;
+		let start = at;
+		for (let i = at + 1; i <= end; i++) {
+			if (i < end && levels[i] === levels[start]) continue;
+			segments.push(characters.slice(start, i).join(""));
+			segmentLevels.push(levels[start]);
+			start = i;
+		}
+		at = end;
+	}
+	return visualOrder(segments, segmentLevels);
+}
+/** This function gives the index after the last character of the word that starts at `start`. */
+function wordEnd(characters, start) {
+	const first = characters[start];
+	if (start + 1 === characters.length || isDelimiter(first)) return start + 1;
+	let end = start + 1;
+	if (!isCjkIdeographOrSymbol(first.codePointAt(0))) {
+		for (; end < characters.length; end++) {
+			const character = characters[end];
+			if (isDelimiter(character) || isCjkIdeographOrSymbol(character.codePointAt(0)) && !modifierLike.test(character)) return end;
+		}
+		return end;
+	}
+	let hasScript = !commonOrInherited.test(first);
+	for (; end < characters.length; end++) {
+		const character = characters[end];
+		if (modifierLike.test(character) || continuesEmoji.test(character)) continue;
+		if (isCjkIdeographOrSymbol(character.codePointAt(0))) {
+			if (commonOrInherited.test(character)) continue;
+			if (!hasScript) {
+				hasScript = true;
+				continue;
+			}
+		}
+		return end;
+	}
+	return end;
+}
+// src/fonts/font.ts
+/** This function reads a TrueType, OpenType or WOFF2 file. */
+function readFont(bytes, options = {}) {
+	const tables = readTables(bytes, options.decompress);
+	const need = (tag) => {
+		const table = tables.get(tag);
+		if (table === void 0) throw new Error(`the font has no ${tag} table`);
+		return table;
+	};
+	const header = readHeader(need("head"), need("hhea"), need("maxp"));
+	const parsed = {
+		tables,
+		header,
+		advances: readAdvances(need("hmtx"), header),
+		characters: readCharacterMap(need("cmap")),
+		glyphClass: readGlyphClasses(tables.get("GDEF")),
+		filter: readGlyphFilter(tables.get("GDEF"), readGlyphClasses(tables.get("GDEF"))),
+		axes: tables.has("fvar") ? readAxes(tables.get("fvar")) : [],
+		points: lazy(() => pointsOf(tables, need("head"), header.numGlyphs))
+	};
+	const modes = {
+		deltas: options.deltas ?? "round",
+		advances: options.advances ?? "auto",
+		metrics: options.metrics ?? "own"
+	};
+	return build(parsed, options.instance ?? {}, modes);
+}
+/** This function gives a function that computes a value at its first call and then keeps it. */
+function lazy(compute) {
+	let done = false;
+	let value;
+	return () => {
+		if (!done) {
+			value = compute();
+			done = true;
+		}
+		return value;
+	};
+}
+/**
+* This function gives the points of each glyph, or `undefined` when the font has no `glyf` table. A WOFF2 file keeps
+* `glyf` in its transformed form, and its `loca` table is then empty.
+*/
+function pointsOf(tables, head, numGlyphs) {
+	const glyf = tables.get("glyf");
+	const loca = tables.get("loca");
+	if (glyf === void 0 || loca === void 0) return void 0;
+	return loca.length === 0 ? readTransformedPointCounts(glyf, numGlyphs) : readPointCounts(glyf, loca, head.i16(50), numGlyphs);
+}
+/** This function gives the font at one instance. */
+function build(parsed, requested, modes) {
+	const { tables, header, characters, glyphClass, axes } = parsed;
+	const { deltas } = modes;
+	const instance = Object.fromEntries(axes.map((axis) => [axis.tag, Math.min(axis.max, Math.max(axis.min, requested[axis.tag] ?? axis.default))]));
+	const coordinates = normalize$1(axes, tables.get("avar"), instance);
+	const variable = coordinates.some((value) => value !== 0);
+	const hvar = tables.get("HVAR");
+	const gvar = tables.get("gvar");
+	const phantoms = gvar !== void 0 && (modes.advances === "gvar" || hvar === void 0) && parsed.points() !== void 0;
+	const advanceSource = !variable ? "hmtx" : phantoms ? "gvar" : hvar !== void 0 ? "HVAR" : "hmtx";
+	const advances = advanceSource === "gvar" ? phantomAdvances(parsed.advances, gvarAdvanceDeltas(gvar, parsed.points().counts, coordinates, deltas)) : instanceAdvances(parsed.advances, advanceSource === "HVAR" ? hvar : void 0, coordinates, deltas);
+	const metrics = modes.metrics === "component" ? parsed.points()?.metrics : void 0;
+	if (metrics !== void 0) componentAdvances(advances, metrics);
+	const gdef = tables.get("GDEF");
+	const storeOffset = variable && gdef !== void 0 && gdef.u16(2) >= 3 ? gdef.u32(14) : 0;
+	const store = storeOffset === 0 ? void 0 : readVariationStore(gdef.part(storeOffset), coordinates);
+	const gpos = tables.get("GPOS");
+	const kern = tables.get("kern");
+	const gsub = tables.get("GSUB");
+	const lookups = /* @__PURE__ */ new Map();
+	const substitutions = /* @__PURE__ */ new Map();
+	const hashed = [
+		tables.get("cmap"),
+		gdef,
+		gpos,
+		kern,
+		tables.get("fvar"),
+		tables.get("avar"),
+		tables.get("HVAR"),
+		gsub
+	];
+	return {
+		epoch: `${header.revision.toString(16).padStart(8, "0")}-${widthHash(header.unitsPerEm, coordinates, advances, hashed)}${deltas === "exact" ? "-exact" : ""}${advanceSource === "gvar" && hvar !== void 0 ? "-gvar" : ""}${metrics !== void 0 ? "-metrics" : ""}`,
+		unitsPerEm: header.unitsPerEm,
+		numGlyphs: header.numGlyphs,
+		axes,
+		instance,
+		coordinates,
+		advanceSource,
+		glyph: (codePoint) => characters.get(codePoint) ?? 0,
+		advance: (glyph) => glyphClass(glyph) === 3 ? 0 : advances[glyph] ?? 0,
+		glyphClass,
+		kerning(script) {
+			let found = lookups.get(script);
+			if (found === void 0) {
+				found = gpos !== void 0 ? readGposKerning(gpos, script, store, parsed.filter) : kern !== void 0 ? readKernTable(kern) : [];
+				lookups.set(script, found);
+			}
+			return found;
+		},
+		substitutions(script, features) {
+			const key = `${script} ${features.join(",")}`;
+			let found = substitutions.get(key);
+			if (found === void 0) {
+				found = gsub === void 0 ? [] : readSubstitutions(gsub, script, features, parsed.filter);
+				substitutions.set(key, found);
+			}
+			return found;
+		},
+		at: (next) => build(parsed, next, modes)
+	};
+}
+/**
+* This function gives each composite glyph the advance of its component with the flag USE_MY_METRICS. A component can
+* have that flag in its own components, so the function follows the chain. A chain of more than 8 steps stops.
+*/
+function componentAdvances(advances, metrics) {
+	const own = Float64Array.from(advances);
+	for (let glyph = 0; glyph < metrics.length; glyph++) {
+		let source = glyph;
+		for (let step = 0; step < 8 && (metrics[source] ?? -1) >= 0; step++) source = metrics[source];
+		if (source !== glyph && source < own.length) advances[glyph] = own[source];
+	}
+}
+/** This function adds the advance delta of each glyph to its default advance. A negative sum becomes 0. */
+function phantomAdvances(advances, deltas) {
+	return Float64Array.from(advances, (advance, glyph) => Math.max(0, advance + (deltas[glyph] ?? 0)));
+}
+/**
+* This function gives 8 hexadecimal digits of FNV-1a. The hash covers the units per em, the coordinates of the instance,
+* the advances and the tables that change a width.
+*/
+function widthHash(unitsPerEm, coordinates, advances, tables) {
+	const parts = [String(unitsPerEm), coordinates.join(",")];
+	const units = Uint16Array.from(advances, (value) => value & 65535);
+	for (let i = 0; i < units.length; i += 4096) parts.push(String.fromCharCode(...units.subarray(i, i + 4096)));
+	for (const table of tables) {
+		parts.push(table === void 0 ? "-" : "+");
+		if (table === void 0) continue;
+		for (let i = 0; i < table.length; i += 8192) parts.push(String.fromCharCode(...table.bytes.subarray(i, i + 8192)));
+	}
+	return fnv1a32(parts.join("")).toString(16).padStart(8, "0");
+}
+/** This function tells if a lookup with the flags `flags` skips a glyph of the GDEF class `glyphClass`. */
+function skips(flags, glyphClass) {
+	return (flags & 8) !== 0 && glyphClass === 3 || (flags & 2) !== 0 && glyphClass === 1 || (flags & 4) !== 0 && glyphClass === 2;
+}
+/**
+* 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.
+*/
+function shapingWords(text) {
+	const words = [];
+	let word = "";
+	for (const character of text) {
+		if (character !== " " && character !== "	") {
+			word += character;
+			continue;
+		}
+		if (word !== "") words.push(word);
+		words.push(character);
+		word = "";
+	}
+	if (word !== "") words.push(word);
+	return words;
+}
+/** The GSUB pass of one set of options: a function that gives the glyphs of one word, and the kerning lookups. */
+function shaperOf(font, options) {
+	const script = options.script ?? "DFLT";
+	const features = options.features ?? defaultFeatures;
+	const kerning = options.kerning === false ? [] : font.kerning(script);
+	if (options.indic !== false && indicScripts.includes(script)) return {
+		substitute: indicShaper(font, script, features),
+		kerning
+	};
+	const joins = options.joining !== false && joiningScripts.includes(script);
+	const lookups = joins ? [] : font.substitutions(script, features);
+	const stages = joins ? joiningStages(features, features.includes("rclt") && font.substitutions(script, ["rclt"]).length > 0).map((stage) => ({
+		stage,
+		lookups: font.substitutions(script, stage.features)
+	})) : [];
+	const substitute = (word) => {
+		const codePoints = [...word].map((character) => character.codePointAt(0));
+		const wordGlyphs = codePoints.map((codePoint) => font.glyph(codePoint));
+		for (const lookup of lookups) lookup.apply(wordGlyphs);
+		if (joins) {
+			const masks = joiningForms(codePoints).map((form) => 128 | (form === void 0 ? 0 : 1 << joiningFeatures.indexOf(form)));
+			for (const { stage, lookups: stageLookups } of stages) {
+				const mask = stage.form === void 0 ? 128 : 1 << joiningFeatures.indexOf(stage.form);
+				for (const lookup of stageLookups) lookup.apply(wordGlyphs, masks, mask);
+			}
+		}
+		return wordGlyphs;
+	};
+	return {
+		substitute,
+		kerning
+	};
+}
+/**
+* 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`.
+*/
+function glyphAdvances(font, text, options = {}) {
+	const { substitute, kerning } = shaperOf(font, options);
+	const canvas = options.shaping === "canvas";
+	const glyphs = [];
+	const advances = [];
+	for (const word of canvas ? canvasWords(text) : shapingWords(text)) {
+		const wordGlyphs = substitute(word);
+		const wordAdvances = wordGlyphs.map((glyph) => font.advance(glyph));
+		if (canvas) kern(font, kerning, wordGlyphs, wordAdvances);
+		glyphs.push(...wordGlyphs);
+		advances.push(...wordAdvances);
+	}
+	if (!canvas) kern(font, kerning, glyphs, advances);
+	return {
+		glyphs,
+		advances
+	};
+}
+/** This function rounds a value to the nearest whole number, and a half goes away from 0, as `roundf` does. */
+function roundHalfAway(value) {
+	return Math.sign(value) * Math.floor(Math.abs(value) + .5);
+}
+/**
+* This function gives a kerning value in 1/65536 px, as HarfBuzz scales it. HarfBuzz scales the value of the ValueRecord
+* with `em_mult`, and the delta of the VariationIndex table in single precision with `em_scalef`.
+*/
+function kerningPosition(value, delta, scale) {
+	const base = Math.round(value - delta);
+	const scaledDelta = delta === 0 ? 0 : roundHalfAway(Math.fround(Math.fround(Math.fround(delta) * scale.xScale) / scale.unitsPerEm));
+	return Math.floor((base * scale.multiplier + 32768) / 65536) + scaledDelta;
+}
+/**
+* This function adds the values of the pair kerning lookups `lookups` to the advances `advances` of the glyphs `glyphs`.
+* When `positions` is given, it also adds each value in 1/65536 px, as HarfBuzz scales it at the scale `scale`.
+*/
+function kern(font, lookups, glyphs, advances, positions, scale) {
+	for (const lookup of lookups) {
+		const next = (from) => {
+			for (let j = from; j < glyphs.length; j++) if (!(lookup.skip?.(glyphs[j]) ?? skips(lookup.flags, font.glyphClass(glyphs[j])))) return j;
+			return -1;
+		};
+		let i = next(0);
+		while (i >= 0) {
+			const j = next(i + 1);
+			if (j < 0) break;
+			const value = lookup.pair(glyphs[i], glyphs[j]);
+			if (value === void 0) {
+				i = j;
+				continue;
+			}
+			advances[i] += value.first;
+			advances[j] += value.second;
+			if (positions !== void 0 && scale !== void 0) {
+				positions[i] += kerningPosition(value.first, value.firstDelta ?? 0, scale);
+				positions[j] += kerningPosition(value.second, value.secondDelta ?? 0, scale);
+			}
+			i = value.skipSecond ? next(j + 1) : j;
+		}
+	}
+}
+/**
+* This function gives the width of a text with the sum `float32`, as Blink adds the widths of a canvas. Each advance in
+* single precision is cut to 1/65536 px, and HarfBuzz scales each kerning value. The sum of a segment of `canvasSegments`
+* is exact, and the sum of the segments is in single precision.
+*/
+function float32Width(font, text, size, options) {
+	const { substitute, kerning } = shaperOf(font, options);
+	const xScale = Math.trunc(Math.fround(size) * 65536);
+	const scale = {
+		xScale,
+		multiplier: Math.floor(xScale * 65536 / font.unitsPerEm),
+		unitsPerEm: font.unitsPerEm
+	};
+	const pxPerUnit = size / font.unitsPerEm;
+	let total = 0;
+	for (const segment of canvasSegments(text)) {
+		const glyphs = substitute(segment);
+		const positions = glyphs.map((glyph) => Math.trunc(Math.fround(font.advance(glyph) * pxPerUnit) * 65536));
+		kern(font, kerning, glyphs, glyphs.map((glyph) => font.advance(glyph)), positions, scale);
+		let units = 0;
+		for (const position of positions) units += position;
+		total = Math.fround(total + Math.fround(units / 65536));
+	}
+	return total;
+}
+/**
+* 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.
+*/
+function measureWidth(font, text, size, options = {}) {
+	if (options.sum === "float32" && options.rounding !== "pixel") return float32Width(font, text, size, options);
+	const { glyphs, advances } = glyphAdvances(font, text, options);
+	if (options.rounding === "pixel") {
+		const scale = size / font.unitsPerEm;
+		let px = 0;
+		glyphs.forEach((glyph, i) => {
+			const base = font.advance(glyph);
+			px += Math.round(Math.round(base * scale * 64) / 64) + Math.round((advances[i] - base) * scale);
+		});
+		return px;
+	}
+	let units = 0;
+	for (const advance of advances) units += advance;
+	return units * size / font.unitsPerEm;
+}
+export { canvasWords as a, shapingWords as i, measureWidth as n, defaultFeatures as o, readFont as r, readTables as s, glyphAdvances as t };
+
+//# sourceMappingURL=font.js.map