reamkit 1.34.0 → 1.35.0

package/dist/esm/layout/styled-layout.js

@@ -1,8 +1,9 @@
-import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
+import { companionOf, companionScale, resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
 import { fontSlotOf, scriptForCodepoint } from "../core/fonts/scripts.js";
 import { hasSubstitutable, substituteLetters } from "../core/font/ligatures.js";
 import { hasIndic, syllableStarts } from "../core/font/indic-shaper.js";
-import { createFontMeasure, shapeGlyphs } from "../core/font/measure.js";
+import { hasCombiningMark, isCombiningMark } from "../core/font/mark-shaper.js";
+import { createFontMeasure, shapeGlyphs, sharedGlyphCodes } from "../core/font/measure.js";
 import "../core/font/index.js";
 import { pageItemBounds } from "./page-doc.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
@@ -2916,9 +2917,20 @@ function runFontKeyAndParsed(options, ascii, bold, italic) {
 * @param italic  …and whether it is italic.
 * @returns The face to draw it with, or `undefined` when nobody has it.
 */
-function fallbackFaceKey(options, cp, bold, italic) {
+function fallbackFaceKey(options, cp, bold, italic, own) {
 	const byFamily = options.registriesByFamily;
 	if (!byFamily || byFamily.size === 0) return void 0;
+	const companion = own === void 0 ? void 0 : companionOf(own);
+	const borrowed = companion ? byFamily.get(companion.family) : void 0;
+	if (companion && borrowed) {
+		const { variant, parsed } = borrowed.resolveByStyle(bold, italic);
+		const widthScale = companionScale(companion, cp, variant);
+		if (widthScale !== void 0 && parsed.glyphForCodepoint(cp) !== 0) return {
+			fontKey: `${companion.family}:${variant}`,
+			parsed,
+			widthScale
+		};
+	}
 	const hanFace = byFamily.has("jp") ? "jp" : byFamily.has("kr") ? "kr" : "sc";
 	const script = scriptForCodepoint(cp, hanFace);
 	const order = script ? [script] : [];
@@ -2955,17 +2967,60 @@ function fallbackFaceKey(options, cp, bold, italic) {
 * @returns The text to set, which is `text` itself unless something was undrawable.
 */
 function drawableText(faces, text) {
-	if (!hasSubstitutable(text)) return text;
-	let out = "";
-	for (const ch of text) {
-		const cp = ch.codePointAt(0);
-		const letters = substituteLetters(cp);
-		const drawable = letters === void 0 || faces(cp).parsed.glyphForCodepoint(cp) !== 0;
-		out += drawable ? ch : letters;
+	if (!hasSubstitutable(text) && !hasCombiningMark(text)) return text;
+	return drawnPieces(faces, text).join("");
+}
+/**
+* What is drawn for each character of `text` — itself, the letters of a
+* ligature nobody can draw (see {@link drawableText}), a composed letter in
+* place of a letter and the marks written apart after it, and nothing for those
+* marks.
+*
+* A letter of the Latin, Greek or Cyrillic alphabets followed by combining
+* marks is set as the letter that composes them (Unicode canonical
+* composition, NFC) where the face that would draw it has one: и + U+0306 is
+* drawn as й, а + U+0306 as Chuvash ӑ, о + U+0308 as Altai ӧ. Set as two
+* glyphs the mark stood at its own default place, beside the letter and above
+* it; Word draws the two exactly as it draws the composed letter. What has no
+* composed form — the stressed а, а and U+0301 — is left to the face's anchors (see
+* `shapeMarks`).
+*
+* @param faces The face each character of the run is drawn with ({@link runFaces}).
+* @param text  The run's text.
+* @returns One string per code point of `text`, empty where a mark went into its letter.
+*/
+function drawnPieces(faces, text) {
+	const cps = [...text].map((ch) => ch.codePointAt(0));
+	const out = cps.map((cp) => String.fromCodePoint(cp));
+	for (let i = 0; i < cps.length; i++) {
+		let end = i + 1;
+		while (end < cps.length && isCombiningMark(cps[end])) end++;
+		if (end > i + 1 && composesInPlace(cps[i])) {
+			const cluster = String.fromCodePoint(...cps.slice(i, end));
+			const composed = cluster.normalize("NFC");
+			const drawable = [...composed].every((ch) => faces(ch.codePointAt(0)).parsed.glyphForCodepoint(ch.codePointAt(0)) !== 0);
+			if (composed !== cluster && drawable) {
+				out[i] = composed;
+				for (let k = i + 1; k < end; k++) out[k] = "";
+			}
+			i = end - 1;
+			continue;
+		}
+		const letters = substituteLetters(cps[i]);
+		if (letters !== void 0 && faces(cps[i]).parsed.glyphForCodepoint(cps[i]) === 0) out[i] = letters;
 	}
 	return out;
 }
 /**
+* Whether a letter's marks are composed into it by the layout: the Latin,
+* Greek and Cyrillic alphabets. The scripts of India compose and reorder in
+* their own shaper, and a CJK compatibility ideograph is not a letter to
+* recompose at all.
+*/
+function composesInPlace(cp) {
+	return cp < 1328 || cp >= 7680 && cp <= 8191;
+}
+/**
 * §9.2.2 — the face a request had to settle for, and what is left to draw.
 *
 * A registry may hold one face and be asked for four: `FontBytesByVariant`
@@ -3082,14 +3137,15 @@ function slotFaces(options, resolved, primary) {
 * slant: a script face is fetched in the regular weight only, and a bold run in
 * it is stroked, which is what F3's synthesis is for.
 */
-function fallbackFace(options, cp, resolved) {
-	const face = fallbackFaceKey(options, cp, resolved.bold, resolved.italic);
-	if (!face) return void 0;
+function fallbackFace(options, cp, resolved, own) {
+	const found = fallbackFaceKey(options, cp, resolved.bold, resolved.italic, own);
+	if (!found) return void 0;
+	const { widthScale, ...face } = found;
 	const variant = face.fontKey.split(":")[1];
 	const got = variant === "bold" || variant === "boldItalic" || variant === "italic" ? variant : "regular";
 	return {
 		...face,
-		...syntheticFace(got, resolved.bold, resolved.italic)
+		...syntheticFace(got, resolved.bold, resolved.italic, widthScale)
 	};
 }
 /**
@@ -3119,11 +3175,41 @@ function runFaces(options, resolved, primary, text) {
 		const own = slots?.get(fontSlotOf(cp, resolved.rtl)) ?? primary;
 		if (own.parsed.glyphForCodepoint(cp) !== 0) return own;
 		if (own !== primary && primary.parsed.glyphForCodepoint(cp) !== 0) return primary;
-		return fallbackFace(options, cp, resolved) ?? own;
+		return fallbackFace(options, cp, resolved, own.fontKey.split(":")[0]) ?? own;
 	};
+	const marks = markFaces(drawing, text);
+	const withMarks = marks ? (cp) => marks.get(cp) ?? drawing(cp) : drawing;
 	const indic = indicFace(drawing, text);
-	if (!indic) return drawing;
-	return (cp) => INDIC_JOINS.has(cp) && indic.parsed.glyphForCodepoint(cp) !== 0 ? indic : drawing(cp);
+	if (!indic) return withMarks;
+	return (cp) => INDIC_JOINS.has(cp) && indic.parsed.glyphForCodepoint(cp) !== 0 ? indic : withMarks(cp);
+}
+/**
+* The face each combining mark of `text` is drawn in, where it is not its
+* own: the face of the letter it sits on, when that face has it. A mark is
+* placed on its letter by the anchors of ONE face (see `shapeMarks`), and a
+* Cambria run sets its Cyrillic in the face Caladea borrows it from while
+* Caladea has an acute of its own — so the acute of a stressed а was drawn by Caladea
+* beside a letter drawn by Noto Serif, and missed it. One face per mark per
+* run: the letter it first sits on decides.
+*
+* @param drawing The face each character is drawn in, letter by letter.
+* @param text    The run's text.
+* @returns The marks to draw in another face, or `undefined` when none.
+*/
+function markFaces(drawing, text) {
+	if (!hasCombiningMark(text)) return void 0;
+	let out;
+	let base;
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (!isCombiningMark(cp)) {
+			base = drawing(cp);
+			continue;
+		}
+		if (!base || out?.has(cp) === true) continue;
+		if (drawing(cp).fontKey !== base.fontKey && base.parsed.glyphForCodepoint(cp) !== 0) (out ??= /* @__PURE__ */ new Map()).set(cp, base);
+	}
+	return out;
 }
 /** The face that draws the first letter of the scripts of India in `text`. */
 function indicFace(drawing, text) {
@@ -3225,6 +3311,7 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 				sink.glyphText ??= /* @__PURE__ */ new Map();
 				if (!sink.glyphText.has(g)) sink.glyphText.set(g, t);
 			}
+			if (!shaped.glyphText) countSharedGlyphs(sink, span.parsed, shown);
 		}
 		if (run.text.includes("	")) for (const stop of resolveParagraphProperties(para.properties, options.styles).tabs) {
 			const ch = stop.leader === void 0 ? void 0 : TAB_LEADER_CHARS.get(stop.leader);
@@ -3390,12 +3477,52 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 			parsed: info.parsed,
 			measure: createFontMeasure(info.parsed, options.layoutProfile !== "word"),
 			gids: info.gids,
-			...info.glyphText ? { glyphText: info.glyphText } : {}
+			...info.glyphText ? { glyphText: info.glyphText } : {},
+			...info.drawnAs ? { glyphChars: mostDrawn(info.drawnAs) } : {}
 		});
 	}
 	return out;
 }
 /**
+* Count, for each glyph of `text` that several characters share in the face's
+* `cmap`, which of them drew it (see `sharedGlyphCodes`).
+*
+* @param sink   The face's collected glyphs, which the counts are kept with.
+* @param parsed The face.
+* @param text   The text the face draws.
+*/
+function countSharedGlyphs(sink, parsed, text) {
+	for (const ch of text) {
+		const cp = ch.codePointAt(0);
+		if (cp < 128) continue;
+		const gid = parsed.glyphForCodepoint(cp);
+		if (gid === 0 || sharedGlyphCodes(parsed, gid) === void 0) continue;
+		sink.drawnAs ??= /* @__PURE__ */ new Map();
+		let counts = sink.drawnAs.get(gid);
+		if (!counts) sink.drawnAs.set(gid, counts = /* @__PURE__ */ new Map());
+		counts.set(cp, (counts.get(cp) ?? 0) + 1);
+	}
+}
+/**
+* The character each shared glyph was drawn for most often; the first drawn
+* where two tie. One /ToUnicode entry cannot name both, and a document that
+* spells the same word in both alphabets with one glyph is rarer than one
+* that does not.
+*/
+function mostDrawn(drawnAs) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [gid, counts] of drawnAs) {
+		let best = -1;
+		let most = 0;
+		for (const [cp, n] of counts) if (n > most) {
+			best = cp;
+			most = n;
+		}
+		out.set(gid, best);
+	}
+	return out;
+}
+/**
 * The one line an empty paragraph still occupies — no tokens, but as tall as
 * the paragraph mark's own font (§17.3.1.31 `w:rPr` on the `w:pPr`, which is
 * exactly the run properties Word keeps for a paragraph that holds no runs).
@@ -3682,17 +3809,18 @@ function mendSplitSyllables(runs) {
 function charColours(options, paragraph, faces, resolved, run, drawn) {
 	const from = run.charProperties;
 	if (!from) return void 0;
+	const pieces = drawn === run.text ? void 0 : drawnPieces(faces, run.text);
 	const hexOf = /* @__PURE__ */ new Map([[run.properties, resolved.colorHex]]);
 	const out = [];
-	let i = 0;
-	for (const ch of run.text) {
-		const props = from[i++] ?? run.properties;
+	const count = [...run.text].length;
+	for (let i = 0; i < count; i++) {
+		const props = from[i] ?? run.properties;
 		let hex = hexOf.get(props);
 		if (hex === void 0) {
 			hex = resolveRunProperties(props, paragraph.properties, options.styles).colorHex;
 			hexOf.set(props, hex);
 		}
-		const letters = drawn === run.text ? 1 : [...drawableText(faces, ch)].length;
+		const letters = pieces ? [...pieces[i]].length : 1;
 		for (let k = 0; k < letters; k++) out.push(hex);
 	}
 	return out.some((hex) => hex !== resolved.colorHex) ? out : void 0;
@@ -4207,7 +4335,7 @@ function lastCodePoint(s) {
 	const chars = [...s];
 	return chars.length > 0 ? chars[chars.length - 1].codePointAt(0) : 0;
 }
-function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
+function paragraphItemStream(tokens, hyphenator, maxLineWidthPt, squeeze = true) {
 	const entries = [];
 	let prevBoxEndCp = null;
 	let prevWasImage = false;
@@ -4254,7 +4382,7 @@ function paragraphItemStream(tokens, hyphenator, maxLineWidthPt) {
 					type: "glue",
 					width: tok.widthPt,
 					stretch: tok.widthPt * .6,
-					shrink: tok.widthPt * GLUE_SHRINK_RATIO
+					shrink: squeeze ? tok.widthPt * GLUE_SHRINK_RATIO : 0
 				} : {
 					type: "box",
 					width: tok.widthPt
@@ -4606,7 +4734,9 @@ function withLeadingTabWidths(tokens, resolved, firstLineWidth) {
 function wrap(tokens, firstLineWidth, otherWidth, resolved, hyphenator, profile, leading, noExpandShiftReturn, lineWidths) {
 	if (tokens.length === 0) return [];
 	const widths = lineWidths ?? [firstLineWidth, otherWidth];
-	const entries = paragraphItemStream(withLeadingTabWidths(tokens, resolved, widths[0] ?? firstLineWidth), hyphenator, Math.max(0, ...widths));
+	const measured = withLeadingTabWidths(tokens, resolved, widths[0] ?? firstLineWidth);
+	const justified = resolved.alignment === "both" || resolved.alignment === "distribute";
+	const entries = paragraphItemStream(measured, hyphenator, Math.max(0, ...widths), justified);
 	const items = entries.map((e) => e.item);
 	const breaks = profile === "ream" ? breakLines(items, widths).breaks : greedyBreakLines(items, widths);
 	const buildLines = (at) => {

package/dist/esm/pdf/cid-font.d.ts

@@ -15,6 +15,12 @@ export interface EmbedTtfOptions {
      * sign's contextual form — so that /ToUnicode names them too.
      */
     readonly glyphText?: ReadonlyMap<number, string>;
+    /**
+     * The character each glyph that several characters share was drawn for —
+     * the Cyrillic schwa, say, where the face draws the Latin one with the same
+     * glyph — so that /ToUnicode names the one the page means.
+     */
+    readonly glyphChars?: ReadonlyMap<number, number>;
 }
 /** The result of {@link embedTtfFont}: the Type 0 font reference plus measurement/encoding helpers. */
 export interface EmbeddedFont {

package/dist/esm/pdf/cid-font.js

@@ -58,7 +58,7 @@ function embedTtfFont(doc, parsed, options = {}) {
 		W: widthRuns.flatMap(([first, ws]) => [first, ws]),
 		CIDToGIDMap: name("Identity")
 	}));
-	const toUnicodeRef = doc.add(deflatedStream({}, buildToUnicodeCMap(parsed, subsetGids, options.glyphText)));
+	const toUnicodeRef = doc.add(deflatedStream({}, buildToUnicodeCMap(parsed, subsetGids, options.glyphText, options.glyphChars)));
 	const type0Ref = doc.add(dict({
 		Type: name("Font"),
 		Subtype: name("Type0"),
@@ -127,7 +127,7 @@ function codeRank(cp) {
 	if (cp >= 64256 && cp <= 65023 || cp >= 65136 && cp <= 65279) return 1;
 	return 0;
 }
-function buildToUnicodeCMap(parsed, subsetGids, glyphText) {
+function buildToUnicodeCMap(parsed, subsetGids, glyphText, glyphChars) {
 	const inSubset = subsetGids ? new Set(subsetGids) : void 0;
 	const gidToCps = /* @__PURE__ */ new Map();
 	const order = [];
@@ -143,6 +143,7 @@ function buildToUnicodeCMap(parsed, subsetGids, glyphText) {
 		gidToCps.set(gid, [cp]);
 		order.push(gid);
 	}
+	for (const [gid, cp] of glyphChars ?? []) if (gidToCps.get(gid)?.length === 1 && parsed.glyphForCodepoint(cp) === gid) gidToCps.set(gid, [cp]);
 	for (const [gid, cps] of gidToCps) {
 		const letters = cps.length === 1 ? lettersForLigature(cps[0]) : void 0;
 		if (letters !== void 0) gidToCps.set(gid, [...letters].map((c) => c.codePointAt(0)));

package/dist/esm/pdf/styled-page-emitter.js

@@ -524,7 +524,8 @@ function embedFontResources(doc, laid, pdfaProfile) {
 		out.set(variant, embedTtfFont(doc, res.parsed, {
 			usedGids: res.gids,
 			cidSet,
-			...res.glyphText ? { glyphText: res.glyphText } : {}
+			...res.glyphText ? { glyphText: res.glyphText } : {},
+			...res.glyphChars ? { glyphChars: res.glyphChars } : {}
 		}));
 	}
 	return out;
@@ -682,7 +683,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 	let lastTz = 100;
 	/** A run's letter spacing, in the text space `Tz` scales (§9.4.4). */
 	const spacingOf = (tok) => {
-		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1) * 100);
+		const tz = Math.round((tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1) * 1e3) / 10;
 		return (tok.resolvedRun.letterSpacingPt ?? 0) / (tz > 0 ? tz / 100 : 1);
 	};
 	/**
@@ -744,7 +745,7 @@ function emitPageContent(page, tagging, gradientNames, alphaStateNames, duotoneS
 			lastStroke = outline.colorHex;
 		}
 		const scale = (tok.synthetic?.widthScale ?? 1) * (tok.resolvedRun.widthScale ?? 1);
-		const tz = Math.round(scale * 100);
+		const tz = Math.round(scale * 1e3) / 10;
 		if (tz !== lastTz) {
 			out.push(`${formatNumber(tz)} Tz`);
 			lastTz = tz;

package/dist/esm/pdf-reader/glyph-names.js

@@ -547,6 +547,335 @@ var GLYPHS = {
 	zero: "0",
 	zeta: "ζ"
 };
+var CYRILLIC = /* @__PURE__ */ new Map([
+	["afii10023", 1025],
+	["Iocyrillic", 1025],
+	["afii10051", 1026],
+	["Djecyrillic", 1026],
+	["afii10052", 1027],
+	["Gjecyrillic", 1027],
+	["afii10053", 1028],
+	["Ecyrillic", 1028],
+	["afii10054", 1029],
+	["Dzecyrillic", 1029],
+	["afii10055", 1030],
+	["Icyrillic", 1030],
+	["afii10056", 1031],
+	["Yicyrillic", 1031],
+	["afii10057", 1032],
+	["Jecyrillic", 1032],
+	["afii10058", 1033],
+	["Ljecyrillic", 1033],
+	["afii10059", 1034],
+	["Njecyrillic", 1034],
+	["afii10060", 1035],
+	["Tshecyrillic", 1035],
+	["afii10061", 1036],
+	["Kjecyrillic", 1036],
+	["afii10062", 1038],
+	["Ushortcyrillic", 1038],
+	["afii10145", 1039],
+	["Dzhecyrillic", 1039],
+	["Acyrillic", 1040],
+	["afii10017", 1040],
+	["afii10018", 1041],
+	["Becyrillic", 1041],
+	["afii10019", 1042],
+	["Vecyrillic", 1042],
+	["afii10020", 1043],
+	["Gecyrillic", 1043],
+	["afii10021", 1044],
+	["Decyrillic", 1044],
+	["afii10022", 1045],
+	["Iecyrillic", 1045],
+	["afii10024", 1046],
+	["Zhecyrillic", 1046],
+	["afii10025", 1047],
+	["Zecyrillic", 1047],
+	["afii10026", 1048],
+	["Iicyrillic", 1048],
+	["afii10027", 1049],
+	["Iishortcyrillic", 1049],
+	["afii10028", 1050],
+	["Kacyrillic", 1050],
+	["afii10029", 1051],
+	["Elcyrillic", 1051],
+	["afii10030", 1052],
+	["Emcyrillic", 1052],
+	["afii10031", 1053],
+	["Encyrillic", 1053],
+	["afii10032", 1054],
+	["Ocyrillic", 1054],
+	["afii10033", 1055],
+	["Pecyrillic", 1055],
+	["afii10034", 1056],
+	["Ercyrillic", 1056],
+	["afii10035", 1057],
+	["Escyrillic", 1057],
+	["afii10036", 1058],
+	["Tecyrillic", 1058],
+	["afii10037", 1059],
+	["Ucyrillic", 1059],
+	["afii10038", 1060],
+	["Efcyrillic", 1060],
+	["afii10039", 1061],
+	["Khacyrillic", 1061],
+	["afii10040", 1062],
+	["Tsecyrillic", 1062],
+	["afii10041", 1063],
+	["Checyrillic", 1063],
+	["afii10042", 1064],
+	["Shacyrillic", 1064],
+	["afii10043", 1065],
+	["Shchacyrillic", 1065],
+	["afii10044", 1066],
+	["Hardsigncyrillic", 1066],
+	["afii10045", 1067],
+	["Yericyrillic", 1067],
+	["afii10046", 1068],
+	["Softsigncyrillic", 1068],
+	["afii10047", 1069],
+	["Ereversedcyrillic", 1069],
+	["afii10048", 1070],
+	["IUcyrillic", 1070],
+	["afii10049", 1071],
+	["IAcyrillic", 1071],
+	["acyrillic", 1072],
+	["afii10065", 1072],
+	["afii10066", 1073],
+	["becyrillic", 1073],
+	["afii10067", 1074],
+	["vecyrillic", 1074],
+	["afii10068", 1075],
+	["gecyrillic", 1075],
+	["afii10069", 1076],
+	["decyrillic", 1076],
+	["afii10070", 1077],
+	["iecyrillic", 1077],
+	["afii10072", 1078],
+	["zhecyrillic", 1078],
+	["afii10073", 1079],
+	["zecyrillic", 1079],
+	["afii10074", 1080],
+	["iicyrillic", 1080],
+	["afii10075", 1081],
+	["iishortcyrillic", 1081],
+	["afii10076", 1082],
+	["kacyrillic", 1082],
+	["afii10077", 1083],
+	["elcyrillic", 1083],
+	["afii10078", 1084],
+	["emcyrillic", 1084],
+	["afii10079", 1085],
+	["encyrillic", 1085],
+	["afii10080", 1086],
+	["ocyrillic", 1086],
+	["afii10081", 1087],
+	["pecyrillic", 1087],
+	["afii10082", 1088],
+	["ercyrillic", 1088],
+	["afii10083", 1089],
+	["escyrillic", 1089],
+	["afii10084", 1090],
+	["tecyrillic", 1090],
+	["afii10085", 1091],
+	["ucyrillic", 1091],
+	["afii10086", 1092],
+	["efcyrillic", 1092],
+	["afii10087", 1093],
+	["khacyrillic", 1093],
+	["afii10088", 1094],
+	["tsecyrillic", 1094],
+	["afii10089", 1095],
+	["checyrillic", 1095],
+	["afii10090", 1096],
+	["shacyrillic", 1096],
+	["afii10091", 1097],
+	["shchacyrillic", 1097],
+	["afii10092", 1098],
+	["hardsigncyrillic", 1098],
+	["afii10093", 1099],
+	["yericyrillic", 1099],
+	["afii10094", 1100],
+	["softsigncyrillic", 1100],
+	["afii10095", 1101],
+	["ereversedcyrillic", 1101],
+	["afii10096", 1102],
+	["iucyrillic", 1102],
+	["afii10097", 1103],
+	["iacyrillic", 1103],
+	["afii10071", 1105],
+	["iocyrillic", 1105],
+	["afii10099", 1106],
+	["djecyrillic", 1106],
+	["afii10100", 1107],
+	["gjecyrillic", 1107],
+	["afii10101", 1108],
+	["ecyrillic", 1108],
+	["afii10102", 1109],
+	["dzecyrillic", 1109],
+	["afii10103", 1110],
+	["icyrillic", 1110],
+	["afii10104", 1111],
+	["yicyrillic", 1111],
+	["afii10105", 1112],
+	["jecyrillic", 1112],
+	["afii10106", 1113],
+	["ljecyrillic", 1113],
+	["afii10107", 1114],
+	["njecyrillic", 1114],
+	["afii10108", 1115],
+	["tshecyrillic", 1115],
+	["afii10109", 1116],
+	["kjecyrillic", 1116],
+	["afii10110", 1118],
+	["ushortcyrillic", 1118],
+	["afii10193", 1119],
+	["dzhecyrillic", 1119],
+	["Omegacyrillic", 1120],
+	["omegacyrillic", 1121],
+	["afii10146", 1122],
+	["Yatcyrillic", 1122],
+	["afii10194", 1123],
+	["yatcyrillic", 1123],
+	["Eiotifiedcyrillic", 1124],
+	["eiotifiedcyrillic", 1125],
+	["Yuslittlecyrillic", 1126],
+	["yuslittlecyrillic", 1127],
+	["Yuslittleiotifiedcyrillic", 1128],
+	["yuslittleiotifiedcyrillic", 1129],
+	["Yusbigcyrillic", 1130],
+	["yusbigcyrillic", 1131],
+	["Yusbigiotifiedcyrillic", 1132],
+	["yusbigiotifiedcyrillic", 1133],
+	["Ksicyrillic", 1134],
+	["ksicyrillic", 1135],
+	["Psicyrillic", 1136],
+	["psicyrillic", 1137],
+	["afii10147", 1138],
+	["Fitacyrillic", 1138],
+	["afii10195", 1139],
+	["fitacyrillic", 1139],
+	["afii10148", 1140],
+	["Izhitsacyrillic", 1140],
+	["afii10196", 1141],
+	["izhitsacyrillic", 1141],
+	["Izhitsadblgravecyrillic", 1142],
+	["izhitsadblgravecyrillic", 1143],
+	["Ukcyrillic", 1144],
+	["ukcyrillic", 1145],
+	["Omegaroundcyrillic", 1146],
+	["omegaroundcyrillic", 1147],
+	["Omegatitlocyrillic", 1148],
+	["omegatitlocyrillic", 1149],
+	["Otcyrillic", 1150],
+	["otcyrillic", 1151],
+	["Koppacyrillic", 1152],
+	["koppacyrillic", 1153],
+	["thousandcyrillic", 1154],
+	["titlocyrilliccmb", 1155],
+	["palatalizationcyrilliccmb", 1156],
+	["dasiapneumatacyrilliccmb", 1157],
+	["psilipneumatacyrilliccmb", 1158],
+	["afii10050", 1168],
+	["Gheupturncyrillic", 1168],
+	["afii10098", 1169],
+	["gheupturncyrillic", 1169],
+	["Ghestrokecyrillic", 1170],
+	["ghestrokecyrillic", 1171],
+	["Ghemiddlehookcyrillic", 1172],
+	["ghemiddlehookcyrillic", 1173],
+	["Zhedescendercyrillic", 1174],
+	["zhedescendercyrillic", 1175],
+	["Zedescendercyrillic", 1176],
+	["zedescendercyrillic", 1177],
+	["Kadescendercyrillic", 1178],
+	["kadescendercyrillic", 1179],
+	["Kaverticalstrokecyrillic", 1180],
+	["kaverticalstrokecyrillic", 1181],
+	["Kastrokecyrillic", 1182],
+	["kastrokecyrillic", 1183],
+	["Kabashkircyrillic", 1184],
+	["kabashkircyrillic", 1185],
+	["Endescendercyrillic", 1186],
+	["endescendercyrillic", 1187],
+	["Enghecyrillic", 1188],
+	["enghecyrillic", 1189],
+	["Pemiddlehookcyrillic", 1190],
+	["pemiddlehookcyrillic", 1191],
+	["Haabkhasiancyrillic", 1192],
+	["haabkhasiancyrillic", 1193],
+	["Esdescendercyrillic", 1194],
+	["esdescendercyrillic", 1195],
+	["Tedescendercyrillic", 1196],
+	["tedescendercyrillic", 1197],
+	["Ustraightcyrillic", 1198],
+	["ustraightcyrillic", 1199],
+	["Ustraightstrokecyrillic", 1200],
+	["ustraightstrokecyrillic", 1201],
+	["Hadescendercyrillic", 1202],
+	["hadescendercyrillic", 1203],
+	["Tetsecyrillic", 1204],
+	["tetsecyrillic", 1205],
+	["Chedescendercyrillic", 1206],
+	["chedescendercyrillic", 1207],
+	["Cheverticalstrokecyrillic", 1208],
+	["cheverticalstrokecyrillic", 1209],
+	["Shhacyrillic", 1210],
+	["shhacyrillic", 1211],
+	["Cheabkhasiancyrillic", 1212],
+	["cheabkhasiancyrillic", 1213],
+	["Chedescenderabkhasiancyrillic", 1214],
+	["chedescenderabkhasiancyrillic", 1215],
+	["palochkacyrillic", 1216],
+	["Zhebrevecyrillic", 1217],
+	["zhebrevecyrillic", 1218],
+	["Kahookcyrillic", 1219],
+	["kahookcyrillic", 1220],
+	["Enhookcyrillic", 1223],
+	["enhookcyrillic", 1224],
+	["Chekhakassiancyrillic", 1227],
+	["chekhakassiancyrillic", 1228],
+	["Abrevecyrillic", 1232],
+	["abrevecyrillic", 1233],
+	["Adieresiscyrillic", 1234],
+	["adieresiscyrillic", 1235],
+	["Aiecyrillic", 1236],
+	["aiecyrillic", 1237],
+	["Iebrevecyrillic", 1238],
+	["iebrevecyrillic", 1239],
+	["Schwacyrillic", 1240],
+	["afii10846", 1241],
+	["schwacyrillic", 1241],
+	["Schwadieresiscyrillic", 1242],
+	["schwadieresiscyrillic", 1243],
+	["Zhedieresiscyrillic", 1244],
+	["zhedieresiscyrillic", 1245],
+	["Zedieresiscyrillic", 1246],
+	["zedieresiscyrillic", 1247],
+	["Dzeabkhasiancyrillic", 1248],
+	["dzeabkhasiancyrillic", 1249],
+	["Imacroncyrillic", 1250],
+	["imacroncyrillic", 1251],
+	["Idieresiscyrillic", 1252],
+	["idieresiscyrillic", 1253],
+	["Odieresiscyrillic", 1254],
+	["odieresiscyrillic", 1255],
+	["Obarredcyrillic", 1256],
+	["obarredcyrillic", 1257],
+	["Obarreddieresiscyrillic", 1258],
+	["obarreddieresiscyrillic", 1259],
+	["Umacroncyrillic", 1262],
+	["umacroncyrillic", 1263],
+	["Udieresiscyrillic", 1264],
+	["udieresiscyrillic", 1265],
+	["Uhungarumlautcyrillic", 1266],
+	["uhungarumlautcyrillic", 1267],
+	["Chedieresiscyrillic", 1268],
+	["chedieresiscyrillic", 1269],
+	["Yerudieresiscyrillic", 1272],
+	["yerudieresiscyrillic", 1273]
+]);
 /**
 * The text a glyph name stands for, or `undefined` when the name says nothing.
 *
@@ -561,6 +890,8 @@ function textForGlyphName(name) {
 	}
 	const known = GLYPHS[base];
 	if (known !== void 0) return known;
+	const cyrillic = CYRILLIC.get(base);
+	if (cyrillic !== void 0) return String.fromCodePoint(cyrillic);
 	if (base.length === 1) return base;
 	const uni = /^uni((?:[0-9A-Fa-f]{4})+)$/u.exec(base);
 	if (uni) {