reamkit 1.33.2 → 1.34.0

package/dist/esm/core/font/indic-shaper.js

@@ -0,0 +1,1146 @@
+import { COMBINING, DECOMPOSITIONS, EXTENDED, MAIN, SINGLES, VEDIC } from "./indic-table.js";
+import { OtlFace, joinSources, mergeClusters, pickScript, planLookups, position, substitute, wouldSubstitute } from "./opentype-lookups.js";
+//#region src/core/font/indic-shaper.ts
+var X = 0;
+var C = 1;
+var V = 2;
+var N = 3;
+var H = 4;
+var ZWNJ = 5;
+var ZWJ = 6;
+var M = 7;
+var SM = 8;
+var A = 10;
+var PLACEHOLDER = 11;
+var DOTTEDCIRCLE = 12;
+var RS = 13;
+var MPST = 14;
+var REPHA = 15;
+var RA = 16;
+var CM = 17;
+var SYMBOL = 18;
+var CS = 19;
+var RA_TO_BECOME_REPH = 1;
+var PRE_M = 2;
+var PRE_C = 3;
+var BASE_C = 4;
+var AFTER_MAIN = 5;
+var BEFORE_SUB = 7;
+var BELOW_C = 8;
+var AFTER_SUB = 9;
+var BEFORE_POST = 10;
+var POST_C = 11;
+var AFTER_POST = 12;
+var SMVD = 13;
+var END = 14;
+var flag = (c) => 1 << c;
+var CONSONANTS = flag(C) | flag(CS) | flag(RA) | flag(CM) | flag(V) | flag(PLACEHOLDER) | flag(DOTTEDCIRCLE);
+var JOINERS = flag(ZWJ) | flag(ZWNJ);
+var CONSONANT_SYLLABLE = 0;
+var VOWEL_SYLLABLE = 1;
+var STANDALONE_CLUSTER = 2;
+var SYMBOL_CLUSTER = 3;
+var BROKEN_CLUSTER = 4;
+var NON_INDIC = 5;
+var SCRIPTS = [
+	[2304, {
+		tags: ["dev2", "deva"],
+		virama: 2381,
+		rephPos: BEFORE_POST,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[2432, {
+		tags: ["bng2", "beng"],
+		virama: 2509,
+		rephPos: AFTER_SUB,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[2560, {
+		tags: ["gur2", "guru"],
+		virama: 2637,
+		rephPos: BEFORE_SUB,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[2688, {
+		tags: ["gjr2", "gujr"],
+		virama: 2765,
+		rephPos: BEFORE_POST,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[2816, {
+		tags: ["ory2", "orya"],
+		virama: 2893,
+		rephPos: AFTER_MAIN,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[2944, {
+		tags: ["tml2", "taml"],
+		virama: 3021,
+		rephPos: AFTER_POST,
+		rephMode: "implicit",
+		blwfPostOnly: false
+	}],
+	[3072, {
+		tags: ["tel2", "telu"],
+		virama: 3149,
+		rephPos: AFTER_POST,
+		rephMode: "explicit",
+		blwfPostOnly: true
+	}],
+	[3200, {
+		tags: ["knd2", "knda"],
+		virama: 3277,
+		rephPos: AFTER_POST,
+		rephMode: "implicit",
+		blwfPostOnly: true
+	}],
+	[3328, {
+		tags: ["mlm2", "mlym"],
+		virama: 3405,
+		rephPos: AFTER_MAIN,
+		rephMode: "logical",
+		blwfPostOnly: false
+	}]
+];
+/** The script whose block a code point is in, or `undefined` for one shared by all. */
+function scriptOf(cp) {
+	if (cp >= 43232 && cp <= 43263) return SCRIPTS[0][1];
+	if (cp < 2304 || cp > 3455) return void 0;
+	if (cp === 2404 || cp === 2405 || cp >= 2385 && cp <= 2388) return void 0;
+	return SCRIPTS[cp - 2304 >> 7][1];
+}
+/**
+* Whether a string holds a letter of one of the scripts this shapes.
+*
+* @param text The text.
+* @returns `true` when one of its characters is in their blocks.
+*/
+function hasIndic(text) {
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c >= 2304 && c <= 3455 && c !== 2404 && c !== 2405) return true;
+	}
+	return false;
+}
+var DIGITS = "0123456789abcdefghijklmnopqrstuv";
+var SINGLE = new Map(SINGLES.map(([cp, c, p]) => [cp, [c, p]]));
+/** A character's category and position; X and END for one the scripts do not use. */
+function properties(cp) {
+	let table;
+	let at = 0;
+	if (cp >= 2304 && cp <= 3455) {
+		table = MAIN;
+		at = cp - 2304;
+	} else if (cp >= 7376 && cp <= 7423) {
+		table = VEDIC;
+		at = cp - 7376;
+	} else if (cp >= 43232 && cp <= 43263) {
+		table = EXTENDED;
+		at = cp - 43232;
+	}
+	if (table === void 0) return SINGLE.get(cp) ?? [X, END];
+	return [DIGITS.indexOf(table[2 * at]), DIGITS.indexOf(table[2 * at + 1])];
+}
+var DECOMPOSE = new Map(DECOMPOSITIONS.map(([cp, a, b]) => [cp, [a, b]]));
+var COMPOSE = new Map(DECOMPOSITIONS.filter(([, , , excluded]) => !excluded).map(([cp, a, b]) => [`${a},${b}`, cp]));
+COMPOSE.set(`2479,2492`, 2527);
+var KEEP_WHOLE = /* @__PURE__ */ new Set([
+	2353,
+	2524,
+	2525,
+	2964
+]);
+var CCC = new Map([
+	...COMBINING,
+	[3157, 4],
+	[3158, 5]
+]);
+var MARK_RE = /\p{M}/u;
+var isMark = (cp) => MARK_RE.test(String.fromCodePoint(cp));
+var WORDISH_RE = /[\p{L}\p{M}\p{Cf}\p{Co}\p{Cs}\p{Cn}]/u;
+var sym = (...cats) => ({
+	kind: "sym",
+	set: cats.reduce((m, c) => m | flag(c), 0)
+});
+var seq = (...parts) => ({
+	kind: "seq",
+	parts
+});
+var alt = (...parts) => ({
+	kind: "alt",
+	parts
+});
+var opt = (part) => ({
+	kind: "opt",
+	part
+});
+var star = (part) => ({
+	kind: "star",
+	part
+});
+function compile(pattern) {
+	const on = [];
+	const to = [];
+	const free = [];
+	const state = () => {
+		on.push(0);
+		to.push(-1);
+		free.push([]);
+		return on.length - 1;
+	};
+	const build = (p) => {
+		const s = state();
+		const e = state();
+		switch (p.kind) {
+			case "sym":
+				on[s] = p.set;
+				to[s] = e;
+				break;
+			case "seq": {
+				let at = s;
+				for (const part of p.parts) {
+					const [ps, pe] = build(part);
+					free[at].push(ps);
+					at = pe;
+				}
+				free[at].push(e);
+				break;
+			}
+			case "alt":
+				for (const part of p.parts) {
+					const [ps, pe] = build(part);
+					free[s].push(ps);
+					free[pe].push(e);
+				}
+				break;
+			case "opt": {
+				const [ps, pe] = build(p.part);
+				free[s].push(ps, e);
+				free[pe].push(e);
+				break;
+			}
+			case "star": {
+				const [ps, pe] = build(p.part);
+				free[s].push(ps, e);
+				free[pe].push(ps, e);
+				break;
+			}
+		}
+		return [s, e];
+	};
+	const [start, accept] = build(pattern);
+	return {
+		on,
+		to,
+		free,
+		start,
+		accept
+	};
+}
+/** How long a match of `nfa` from `from` can be, up to `limit`; 0 for none. */
+function longest(nfa, cats, from, limit) {
+	const close = (states) => {
+		const out = /* @__PURE__ */ new Set();
+		const stack = [...states];
+		while (stack.length > 0) {
+			const s = stack.pop();
+			if (out.has(s)) continue;
+			out.add(s);
+			for (const t of nfa.free[s]) stack.push(t);
+		}
+		return out;
+	};
+	let states = close([nfa.start]);
+	let best = 0;
+	for (let i = from; i < cats.length && i - from < limit; i++) {
+		const bit = flag(cats[i]);
+		const next = [];
+		for (const s of states) if (nfa.on[s] & bit) next.push(nfa.to[s]);
+		if (next.length === 0) break;
+		states = close(next);
+		if (states.has(nfa.accept)) best = i - from + 1;
+	}
+	return best;
+}
+var RULES = (() => {
+	const c = sym(C, RA);
+	const n = seq(opt(seq(opt(sym(ZWNJ)), sym(RS))), opt(seq(sym(N), opt(sym(N)))));
+	const z = sym(ZWJ, ZWNJ);
+	const reph = alt(seq(sym(RA), sym(H)), sym(REPHA));
+	const cn = seq(c, opt(sym(ZWJ)), opt(n));
+	const symbol = seq(sym(SYMBOL), opt(sym(N)));
+	const matraGroup = seq(star(z), alt(sym(M), seq(opt(sym(SM)), sym(MPST))), opt(sym(N)), opt(sym(H)));
+	const syllableTail = seq(opt(seq(opt(z), sym(SM), opt(sym(SM)), opt(sym(ZWNJ)))), star(sym(A)));
+	const halantGroup = seq(opt(z), sym(H), opt(seq(sym(ZWJ), opt(sym(N)))));
+	const halantOrMatraGroup = alt(alt(halantGroup, seq(sym(H), sym(ZWNJ))), star(matraGroup));
+	const tail = seq(star(seq(halantGroup, cn)), opt(sym(CM)), halantOrMatraGroup, syllableTail);
+	return [
+		[CONSONANT_SYLLABLE, compile(seq(opt(sym(REPHA, CS)), cn, tail))],
+		[VOWEL_SYLLABLE, compile(seq(opt(reph), sym(V), opt(n), alt(sym(ZWJ), tail)))],
+		[STANDALONE_CLUSTER, compile(seq(alt(seq(opt(sym(REPHA, CS)), sym(PLACEHOLDER)), seq(opt(reph), sym(DOTTEDCIRCLE))), opt(n), tail))],
+		[SYMBOL_CLUSTER, compile(seq(symbol, syllableTail))],
+		[BROKEN_CLUSTER, compile(seq(opt(reph), opt(n), tail))]
+	];
+})();
+var MAX_SYLLABLE = 64;
+/** Cut a run of categories into syllables, longest match first: [start, end, type] each. */
+function syllables(cats) {
+	const out = [];
+	let i = 0;
+	while (i < cats.length) {
+		let len = 0;
+		let type = NON_INDIC;
+		for (const [t, nfa] of RULES) {
+			const l = longest(nfa, cats, i, MAX_SYLLABLE);
+			if (l > len) {
+				len = l;
+				type = t;
+			}
+		}
+		if (len === 0) len = 1;
+		out.push([
+			i,
+			i + len,
+			type
+		]);
+		i += len;
+	}
+	return out;
+}
+/**
+* Where the syllables of the scripts of India begin in a text, by the grammar
+* the shaper cuts them with: a syllable is the unit a reph, a conjunct or a
+* vowel sign is shaped within, and shaped in two halves it falls apart.
+*
+* @param text The text.
+* @returns Per code point: whether a syllable — or anything that is not one —
+*          begins at it.
+*/
+function syllableStarts(text) {
+	const cats = [...text].map((ch) => properties(ch.codePointAt(0))[0]);
+	const out = cats.map(() => false);
+	for (const [start] of syllables(cats)) out[start] = true;
+	return out;
+}
+var GLOBAL = 1;
+var RPHF = 2;
+var PREF = 4;
+var BLWF = 8;
+var ABVF = 16;
+var HALF = 32;
+var PSTF = 64;
+var INIT = 128;
+var indic = (tag, mask = GLOBAL) => ({
+	tag,
+	mask,
+	manualZwj: true,
+	manualZwnj: true,
+	perSyllable: true
+});
+var plain = (tag) => ({
+	tag,
+	mask: GLOBAL
+});
+var markFeature = (tag) => ({
+	tag,
+	mask: GLOBAL,
+	manualZwj: true,
+	manualZwnj: true
+});
+/** The features, stage by stage: each stage runs to the end before the next. */
+var BASIC = [
+	indic("nukt"),
+	indic("akhn"),
+	indic("rphf", RPHF),
+	indic("rkrf"),
+	indic("pref", PREF),
+	indic("blwf", BLWF),
+	indic("abvf", ABVF),
+	indic("half", HALF),
+	indic("pstf", PSTF),
+	indic("vatu"),
+	indic("cjct")
+];
+var PRESENTATION = [
+	indic("init", INIT),
+	indic("pres"),
+	indic("abvs"),
+	indic("blws"),
+	indic("psts"),
+	indic("haln"),
+	...[
+		"abvm",
+		"blwm",
+		"rlig",
+		"calt",
+		"clig",
+		"curs",
+		"dist",
+		"liga",
+		"rclt"
+	].map(plain),
+	markFeature("mark"),
+	markFeature("mkmk")
+];
+var plans = /* @__PURE__ */ new WeakMap();
+function planFor(parsed, config) {
+	let byScript = plans.get(parsed);
+	if (!byScript) {
+		byScript = /* @__PURE__ */ new Map();
+		plans.set(parsed, byScript);
+	}
+	const had = byScript.get(config);
+	if (had !== void 0) return had ?? void 0;
+	const face = OtlFace.of(parsed);
+	const script = pickScript(face.gsub, config.tags);
+	if (script === void 0 || !config.tags.includes(script)) {
+		byScript.set(config, null);
+		return;
+	}
+	const tags = config.tags;
+	const oldSpec = !script.endsWith("2");
+	const has = /* @__PURE__ */ new Set();
+	for (const f of [...BASIC, ...PRESENTATION]) if (planLookups(face.gsub, tags, [f]).length > 0) has.add(f.tag);
+	const only = (tag) => planLookups(face.gsub, tags, [BASIC.find((f) => f.tag === tag)]);
+	const plan = {
+		config,
+		face,
+		oldSpec,
+		early: planLookups(face.gsub, tags, [
+			plain("rvrn"),
+			plain("ltra"),
+			plain("ltrm"),
+			{
+				tag: "locl",
+				mask: GLOBAL,
+				perSyllable: true
+			},
+			{
+				tag: "ccmp",
+				mask: GLOBAL,
+				perSyllable: true
+			}
+		]),
+		basic: BASIC.map((f) => planLookups(face.gsub, tags, [f])),
+		late: planLookups(face.gsub, tags, PRESENTATION),
+		has,
+		rphf: only("rphf"),
+		pref: only("pref"),
+		blwf: only("blwf"),
+		pstf: only("pstf"),
+		vatu: only("vatu"),
+		zeroContext: !oldSpec && config !== SCRIPTS[8][1],
+		virama: parsed.glyphForCodepoint(config.virama),
+		consonants: /* @__PURE__ */ new Map()
+	};
+	byScript.set(config, plan);
+	return plan;
+}
+/**
+* Shape a run of text in one face, when the face has OpenType layout for the
+* script of India its text is in.
+*
+* @param parsed The face.
+* @param text   The text.
+* @param kern   Whether to apply the face's `kern` feature (the layout profile decides).
+* @returns The shaped glyphs, or `undefined` when the text holds no letter of
+*          those scripts or the face has no layout for them — the caller's
+*          own shaping applies then.
+*/
+function shapeIndic(parsed, text, kern = true) {
+	const cps = [...text].map((ch) => ch.codePointAt(0));
+	const runs = [];
+	cps.forEach((cp, i) => {
+		const config = scriptOf(cp);
+		const last = runs[runs.length - 1];
+		if (last && (!config || config === last.config)) last.to = i + 1;
+		else if (config) runs.push({
+			config,
+			from: last ? i : 0,
+			to: i + 1
+		});
+	});
+	if (runs.length === 0) return void 0;
+	runs[runs.length - 1].to = cps.length;
+	const out = emptyRun();
+	let shapedAny = false;
+	for (const run of runs) {
+		const plan = planFor(parsed, run.config);
+		const shaped = plan ? shapeRun(plan, parsed, cps.slice(run.from, run.to), kern) : unshaped(parsed, cps.slice(run.from, run.to));
+		shapedAny ||= plan !== void 0;
+		out.gids.push(...shaped.gids);
+		out.clusters.push(...shaped.clusters.map((c) => c + run.from));
+		out.sources.push(...shaped.sources.map((s) => s.map((c) => c + run.from)));
+		out.advances.push(...shaped.advances);
+		out.xOffsets.push(...shaped.xOffsets);
+		out.yOffsets.push(...shaped.yOffsets);
+	}
+	return shapedAny ? out : void 0;
+}
+/** A run with no glyphs yet. */
+function emptyRun() {
+	return {
+		gids: [],
+		clusters: [],
+		sources: [],
+		advances: [],
+		xOffsets: [],
+		yOffsets: []
+	};
+}
+/** Each character its own glyph, at its own advance. */
+function unshaped(parsed, cps) {
+	const gids = cps.map((cp) => parsed.glyphForCodepoint(cp));
+	return {
+		gids,
+		clusters: cps.map((_, i) => i),
+		sources: cps.map((_, i) => [i]),
+		advances: gids.map((g) => parsed.advanceWidths[g] ?? 0),
+		xOffsets: gids.map(() => 0),
+		yOffsets: gids.map(() => 0)
+	};
+}
+/** Shape the characters of one script in a face that has its layout. */
+function shapeRun(plan, parsed, cps, kern) {
+	const { config } = plan;
+	const buf = normalize(parsed, plan.face, cps);
+	for (const g of buf) {
+		[g.cat, g.pos] = properties(g.cp);
+		if (g.cat === ZWJ) g.joiner = "zwj";
+		else if (g.cat === ZWNJ) g.joiner = "zwnj";
+	}
+	let serial = 0;
+	for (const [start, end, type] of syllables(buf.map((g) => g.cat))) {
+		serial++;
+		for (let i = start; i < end; i++) {
+			buf[i].syllable = serial;
+			buf[i].type = type;
+		}
+	}
+	substitute(plan.face, plan.early, buf);
+	initialReordering(plan, parsed, buf);
+	for (const steps of plan.basic) substitute(plan.face, steps, buf);
+	finalReordering(plan, buf);
+	substitute(plan.face, plan.late, buf);
+	const gpos = planLookups(plan.face.gpos, config.tags, [
+		...[
+			"abvm",
+			"blwm",
+			"curs",
+			"dist",
+			...kern ? ["kern"] : []
+		].map(plain),
+		markFeature("mark"),
+		markFeature("mkmk")
+	]);
+	const pos = position(plan.face, gpos, buf);
+	removeIgnorables(buf, pos);
+	const out = emptyRun();
+	buf.forEach((g, i) => {
+		const p = pos[i];
+		out.gids.push(g.gid);
+		out.clusters.push(g.cluster);
+		out.sources.push(g.sources);
+		out.advances.push(p.xAdvance);
+		out.xOffsets.push(p.xOffset);
+		out.yOffsets.push(p.yOffset);
+	});
+	return out;
+}
+var IGNORABLE = /* @__PURE__ */ new Set([
+	8203,
+	8204,
+	8205,
+	8206,
+	8207,
+	8288,
+	65279
+]);
+/**
+* Take out what draws nothing, once the lookups are done with it: a join
+* control has decided whether a conjunct forms and whether a mark attaches,
+* and is not drawn. Its cluster goes to a neighbour the way HarfBuzz's
+* `delete_glyph` gives it.
+*/
+function removeIgnorables(buf, pos) {
+	for (let i = 0; i < buf.length; i++) {
+		const g = buf[i];
+		if (!IGNORABLE.has(g.cp) || ligated(g)) continue;
+		const prev = buf[i - 1];
+		const next = buf[i + 1];
+		if (next?.cluster === g.cluster || prev?.cluster === g.cluster) {} else if (prev) {
+			if (g.cluster < prev.cluster) {
+				const old = prev.cluster;
+				for (let k = i; k > 0 && buf[k - 1].cluster === old; k--) buf[k - 1].cluster = g.cluster;
+			}
+		} else if (next) mergeClusters(buf, i, i + 2);
+		buf.splice(i, 1);
+		pos.splice(i, 1);
+		i--;
+	}
+}
+var VOWEL_CONSTRAINTS = new Map([
+	[2309, [
+		2362,
+		2363,
+		2366,
+		2373,
+		2374,
+		2377,
+		2378,
+		2379,
+		2380,
+		2383,
+		2390,
+		2391
+	]],
+	[2310, [
+		2362,
+		2373,
+		2374,
+		2375,
+		2376
+	]],
+	[2313, [2369]],
+	[2319, [
+		2373,
+		2374,
+		2375
+	]],
+	[2437, [2494]],
+	[2443, [2499]],
+	[2444, [2530]],
+	[2565, [
+		2622,
+		2632,
+		2636
+	]],
+	[2674, [
+		2623,
+		2624,
+		2631
+	]],
+	[2675, [
+		2625,
+		2626,
+		2635
+	]],
+	[2693, [
+		2750,
+		2757,
+		2759,
+		2760,
+		2761,
+		2763,
+		2764
+	]],
+	[2757, [2750]],
+	[2821, [2878]],
+	[2831, [2903]],
+	[2835, [2903]],
+	[2949, [3010]],
+	[3090, [3148, 3157]],
+	[3135, [3157]],
+	[3142, [3157]],
+	[3146, [3157]],
+	[3209, [3262]],
+	[3211, [3262]],
+	[3218, [3276]],
+	[3335, [3415]],
+	[3337, [3415]],
+	[3342, [3398]],
+	[3346, [3390, 3415]]
+].map(([first, signs]) => [first, new Set(signs)]));
+/**
+* The characters with a dotted circle put into each sequence that spells one
+* vowel as another (see {@link VOWEL_CONSTRAINTS}), each with its cluster and
+* its index in the text: the circle takes the cluster of the sign it carries,
+* and stands for no character.
+*/
+function constrainVowels(cps, clusters) {
+	const out = [];
+	const take = (i) => {
+		out.push([
+			cps[i],
+			clusters[i],
+			[i]
+		]);
+	};
+	let i = 0;
+	while (i < cps.length) {
+		const cp = cps[i];
+		let matched = i + 1 < cps.length && VOWEL_CONSTRAINTS.get(cp)?.has(cps[i + 1]) === true;
+		if (cp === 2352 && cps[i + 1] === 2381 && cps[i + 2] === 2311) {
+			take(i);
+			i++;
+			matched = true;
+		}
+		take(i);
+		i++;
+		if (matched && i < cps.length) {
+			out.push([
+				9676,
+				clusters[i],
+				[]
+			]);
+			take(i);
+			i++;
+		}
+	}
+	return out;
+}
+/**
+* Characters to glyphs the way HarfBuzz's normalizer does for these scripts:
+* every grapheme one cluster; a composite taken apart wherever the face has
+* its parts (a nukta letter becomes its letter and the nukta, a two-part vowel
+* sign its two parts); marks in canonical order; and a letter and a mark put
+* back together where the face draws the composite and Unicode allows it.
+* Each glyph stands for its own character, the parts of a composite each for
+* the composite, and a letter put back together for both of its characters.
+*/
+function normalize(parsed, face, cps) {
+	const glyph = (cp) => parsed.glyphForCodepoint(cp);
+	const make = (cp, cluster, sources) => {
+		const gid = glyph(cp);
+		return {
+			gid,
+			cluster,
+			mask: GLOBAL,
+			cls: face.glyphClass(gid),
+			syllable: 0,
+			ligId: 0,
+			ligComp: 0,
+			sources,
+			cp,
+			cat: X,
+			pos: END,
+			type: NON_INDIC
+		};
+	};
+	const clusters = [];
+	cps.forEach((cp, i) => {
+		const continues = i > 0 && (isMark(cp) || cp === 8205);
+		clusters.push(continues ? clusters[i - 1] : i);
+	});
+	const decompose = (cp, out) => {
+		if (KEEP_WHOLE.has(cp)) return false;
+		const parts = DECOMPOSE.get(cp);
+		if (!parts) return false;
+		const [a, b] = parts;
+		if (glyph(b) === 0) return false;
+		const mark = out.length;
+		if (decompose(a, out)) {
+			out.push(b);
+			return true;
+		}
+		out.length = mark;
+		if (glyph(a) === 0) return false;
+		out.push(a, b);
+		return true;
+	};
+	const buf = [];
+	for (const [cp, cluster, sources] of constrainVowels(cps, clusters)) {
+		const parts = [];
+		if (decompose(cp, parts)) for (const p of parts) buf.push(make(p, cluster, sources));
+		else buf.push(make(cp, cluster, sources));
+	}
+	const ccc = (g) => CCC.get(g.cp) ?? 0;
+	for (let i = 0; i < buf.length; i++) {
+		if (ccc(buf[i]) === 0) continue;
+		let end = i + 1;
+		while (end < buf.length && ccc(buf[end]) !== 0) end++;
+		for (let k = i + 1; k < end; k++) {
+			let j = k;
+			while (j > i && ccc(buf[j - 1]) > ccc(buf[k])) j--;
+			if (j === k) continue;
+			mergeClusters(buf, j, k + 1);
+			const [moved] = buf.splice(k, 1);
+			buf.splice(j, 0, moved);
+		}
+		i = end;
+	}
+	const out = [];
+	let starter = -1;
+	for (const g of buf) {
+		if (isMark(g.cp) && starter >= 0) {
+			const s = out[starter];
+			const prev = out[out.length - 1];
+			const composed = isMark(s.cp) ? void 0 : COMPOSE.get(`${s.cp},${g.cp}`);
+			if (composed !== void 0 && (starter === out.length - 1 || ccc(prev) < ccc(g)) && glyph(composed) !== 0) {
+				s.cluster = Math.min(s.cluster, g.cluster);
+				s.sources = joinSources([s, g]) ?? [];
+				s.cp = composed;
+				s.gid = glyph(composed);
+				s.cls = face.glyphClass(s.gid);
+				continue;
+			}
+		}
+		out.push(g);
+		if (ccc(g) === 0) starter = out.length - 1;
+	}
+	return out;
+}
+var ligated = (g) => ((g.props ?? 0) & 2) !== 0;
+var isOneOf = (g, flags) => !ligated(g) && (flag(g.cat) & flags) !== 0;
+var isConsonant = (g) => isOneOf(g, CONSONANTS);
+var isJoiner = (g) => isOneOf(g, JOINERS);
+var isHalant = (g) => isOneOf(g, flag(H));
+/** Each consonant's form by the face: below-base, post-base, or a base. */
+function consonantPosition(plan, gid) {
+	const known = plan.consonants.get(gid);
+	if (known !== void 0) return known;
+	const v = plan.virama;
+	const would = (steps) => wouldSubstitute(plan.face, steps, [v, gid], plan.zeroContext) || wouldSubstitute(plan.face, steps, [gid, v], plan.zeroContext);
+	const pos = would(plan.blwf) || would(plan.vatu) ? BELOW_C : would(plan.pstf) || would(plan.pref) ? POST_C : BASE_C;
+	plan.consonants.set(gid, pos);
+	return pos;
+}
+function eachSyllable(buf, visit) {
+	let start = 0;
+	while (start < buf.length) {
+		let end = start + 1;
+		while (end < buf.length && buf[end].syllable === buf[start].syllable) end++;
+		visit(start, end);
+		start = end;
+	}
+}
+function initialReordering(plan, parsed, buf) {
+	if (plan.virama) {
+		for (const g of buf) if (g.pos === BASE_C) g.pos = consonantPosition(plan, g.gid);
+	}
+	insertDottedCircles(parsed, plan.face, buf);
+	eachSyllable(buf, (start, end) => {
+		const type = buf[start].type;
+		if (type === SYMBOL_CLUSTER || type === NON_INDIC) return;
+		reorderSyllable(plan, buf, start, end);
+	});
+}
+/** A broken cluster — a mark with nothing to sit on — is given a dotted circle to sit on. */
+function insertDottedCircles(parsed, face, buf) {
+	if (!buf.some((g) => g.type === BROKEN_CLUSTER)) return;
+	const gid = parsed.glyphForCodepoint(9676);
+	if (!gid) return;
+	let last = 0;
+	for (let i = 0; i < buf.length; i++) {
+		const g = buf[i];
+		if (g.type !== BROKEN_CLUSTER || g.syllable === last) continue;
+		last = g.syllable;
+		let at = i;
+		while (at < buf.length && buf[at].syllable === last && buf[at].cat === REPHA) at++;
+		buf.splice(at, 0, {
+			gid,
+			cluster: g.cluster,
+			mask: g.mask,
+			cls: face.glyphClass(gid),
+			syllable: g.syllable,
+			ligId: 0,
+			ligComp: 0,
+			sources: [],
+			cp: 9676,
+			cat: DOTTEDCIRCLE,
+			pos: END,
+			type: BROKEN_CLUSTER
+		});
+		i = at;
+	}
+}
+function reorderSyllable(plan, buf, start, end) {
+	const { config } = plan;
+	if (config === SCRIPTS[7][1] && start + 3 <= end && buf[start].cat === RA && buf[start + 1].cat === H && buf[start + 2].cat === ZWJ) {
+		mergeClusters(buf, start + 1, start + 3);
+		[buf[start + 1], buf[start + 2]] = [buf[start + 2], buf[start + 1]];
+	}
+	let base = end;
+	let hasReph = false;
+	let limit = start;
+	if (plan.has.has("rphf") && start + 3 <= end && (config.rephMode === "implicit" && !isJoiner(buf[start + 2]) || config.rephMode === "explicit" && buf[start + 2].cat === ZWJ)) {
+		const glyphs = [buf[start].gid, buf[start + 1].gid];
+		if (wouldSubstitute(plan.face, plan.rphf, glyphs, plan.zeroContext) || config.rephMode === "explicit" && wouldSubstitute(plan.face, plan.rphf, [...glyphs, buf[start + 2].gid], plan.zeroContext)) {
+			limit += 2;
+			while (limit < end && isJoiner(buf[limit])) limit++;
+			base = start;
+			hasReph = true;
+		}
+	} else if (config.rephMode === "logical" && buf[start].cat === REPHA) {
+		limit += 1;
+		while (limit < end && isJoiner(buf[limit])) limit++;
+		base = start;
+		hasReph = true;
+	}
+	{
+		let i = end;
+		let seenBelow = false;
+		do {
+			i--;
+			const g = buf[i];
+			if (isConsonant(g)) {
+				if (g.pos !== BELOW_C && (g.pos !== POST_C || seenBelow)) {
+					base = i;
+					break;
+				}
+				if (g.pos === BELOW_C) seenBelow = true;
+				base = i;
+			} else if (start < i && g.cat === ZWJ && buf[i - 1].cat === H) break;
+		} while (i > limit);
+	}
+	if (hasReph && base === start && limit - base <= 2) hasReph = false;
+	for (let i = start; i < base; i++) buf[i].pos = Math.min(PRE_C, buf[i].pos);
+	if (base < end) buf[base].pos = BASE_C;
+	if (hasReph) buf[start].pos = RA_TO_BECOME_REPH;
+	if (plan.oldSpec) {
+		const kannada = config === SCRIPTS[7][1];
+		for (let i = base + 1; i < end; i++) {
+			if (buf[i].cat !== H) continue;
+			let j = end - 1;
+			for (; j > i; j--) if (isConsonant(buf[j]) || kannada && buf[j].cat === H) break;
+			if (buf[j].cat !== H && j > i) {
+				const [t] = buf.splice(i, 1);
+				buf.splice(j, 0, t);
+			}
+			break;
+		}
+	}
+	{
+		let lastPos = 0;
+		for (let i = start; i < end; i++) {
+			const g = buf[i];
+			if (flag(g.cat) & (JOINERS | flag(N) | flag(RS) | flag(CM) | flag(H))) {
+				g.pos = lastPos;
+				if (g.cat === H && g.pos === PRE_M) {
+					for (let j = i; j > start; j--) if (buf[j - 1].pos !== PRE_M) {
+						g.pos = buf[j - 1].pos;
+						break;
+					}
+				}
+			} else if (g.pos !== SMVD) {
+				if (g.cat === MPST && i > start && buf[i - 1].cat === SM) buf[i - 1].pos = g.pos;
+				lastPos = g.pos;
+			}
+		}
+	}
+	{
+		let last = base;
+		for (let i = base + 1; i < end; i++) {
+			const g = buf[i];
+			if (isConsonant(g)) {
+				for (let j = last + 1; j < i; j++) if (buf[j].pos < SMVD) buf[j].pos = g.pos;
+				last = i;
+			} else if (g.cat === M || g.cat === MPST) last = i;
+		}
+	}
+	{
+		const slice = buf.slice(start, end);
+		slice.forEach((g, k) => g.ord = k);
+		slice.sort((a, b) => a.pos - b.pos || a.ord - b.ord);
+		for (let i = start; i < end; i++) buf[i] = slice[i - start];
+		base = end;
+		let firstLeft = end;
+		let lastLeft = end;
+		for (let i = start; i < end; i++) {
+			if (buf[i].pos === BASE_C) {
+				base = i;
+				break;
+			}
+			if (buf[i].pos === PRE_M) {
+				if (firstLeft === end) firstLeft = i;
+				lastLeft = i;
+			}
+		}
+		if (firstLeft < lastLeft) {
+			reverse(buf, firstLeft, lastLeft + 1);
+			let i = firstLeft;
+			for (let j = i; j <= lastLeft; j++) if (buf[j].cat === M || buf[j].cat === MPST) {
+				reverse(buf, i, j + 1);
+				i = j + 1;
+			}
+		}
+		if (plan.oldSpec || end - start > 127) mergeClusters(buf, base, end);
+		else {
+			const seen = /* @__PURE__ */ new Set();
+			const at = (i) => start + buf[i].ord;
+			for (let i = base; i < end; i++) {
+				if (seen.has(i)) continue;
+				let min = i;
+				let max = i;
+				let j = at(i);
+				while (j !== i && !seen.has(j)) {
+					min = Math.min(min, j);
+					max = Math.max(max, j);
+					seen.add(j);
+					j = at(j);
+				}
+				mergeClusters(buf, Math.max(base, min), max + 1);
+			}
+		}
+	}
+	for (let i = start; i < end && buf[i].pos === RA_TO_BECOME_REPH; i++) buf[i].mask |= RPHF;
+	const pre = HALF | (!plan.oldSpec && !config.blwfPostOnly ? BLWF : 0);
+	for (let i = start; i < base; i++) buf[i].mask |= pre;
+	for (let i = base + 1; i < end; i++) buf[i].mask |= 88;
+	if (plan.oldSpec && config === SCRIPTS[0][1]) {
+		for (let i = start; i + 1 < base; i++) if (buf[i].cat === RA && buf[i + 1].cat === H && (i + 2 === base || buf[i + 2].cat !== ZWJ)) {
+			buf[i].mask |= BLWF;
+			buf[i + 1].mask |= BLWF;
+		}
+	}
+	if (plan.has.has("pref") && base + 2 < end) {
+		for (let i = base + 1; i + 1 < end; i++) if (wouldSubstitute(plan.face, plan.pref, [buf[i].gid, buf[i + 1].gid], plan.zeroContext)) {
+			buf[i].mask |= PREF;
+			buf[i + 1].mask |= PREF;
+			break;
+		}
+	}
+	for (let i = start + 1; i < end; i++) {
+		if (!isJoiner(buf[i]) || buf[i].cat !== ZWNJ) continue;
+		let j = i;
+		do {
+			j--;
+			buf[j].mask &= -33;
+		} while (j > start && !isConsonant(buf[j]));
+	}
+}
+/** Reverse `buf[start..end)` in place. */
+function reverse(buf, start, end) {
+	for (let a = start, b = end - 1; a < b; a++, b--) [buf[a], buf[b]] = [buf[b], buf[a]];
+}
+function finalReordering(plan, buf) {
+	eachSyllable(buf, (start, end) => finalSyllable(plan, buf, start, end));
+}
+function finalSyllable(plan, buf, start, end) {
+	const { config } = plan;
+	const malayalamOrTamil = config === SCRIPTS[8][1] || config === SCRIPTS[5][1];
+	if (plan.virama) for (let i = start; i < end; i++) {
+		const g = buf[i];
+		const props = g.props ?? 0;
+		if (g.gid === plan.virama && props & 2 && props & 4) {
+			g.cat = H;
+			g.props = props & -7;
+		}
+	}
+	let tryPref = plan.has.has("pref");
+	const formed = (g) => {
+		const props = g.props ?? 0;
+		return (props & 2) !== 0 && (props & 4) === 0;
+	};
+	let base = start;
+	for (; base < end; base++) {
+		if (buf[base].pos < BASE_C) continue;
+		if (tryPref && base + 1 < end) {
+			for (let i = base + 1; i < end; i++) {
+				if ((buf[i].mask & PREF) === 0) continue;
+				if (!((buf[i].props ?? 0) & 1 && formed(buf[i]))) {
+					base = i;
+					while (base < end && isHalant(buf[base])) base++;
+					if (base < end) buf[base].pos = BASE_C;
+					tryPref = false;
+				}
+				break;
+			}
+			if (base === end) break;
+		}
+		if (config === SCRIPTS[8][1]) for (let i = base + 1; i < end; i++) {
+			while (i < end && isJoiner(buf[i])) i++;
+			if (i === end || !isHalant(buf[i])) break;
+			i++;
+			while (i < end && isJoiner(buf[i])) i++;
+			if (i < end && isConsonant(buf[i]) && buf[i].pos === BELOW_C) {
+				base = i;
+				buf[base].pos = BASE_C;
+			}
+		}
+		if (start < base && buf[base].pos > BASE_C) base--;
+		break;
+	}
+	if (base === end && start < base && isOneOf(buf[base - 1], flag(ZWJ))) base--;
+	if (base < end) while (start < base && isOneOf(buf[base], flag(N) | flag(H))) base--;
+	if (start + 1 < end && start < base) {
+		let newPos = base === end ? base - 2 : base - 1;
+		if (!malayalamOrTamil) for (;;) {
+			while (newPos > start && !isOneOf(buf[newPos], flag(M) | flag(MPST) | flag(H))) newPos--;
+			if (isHalant(buf[newPos]) && buf[newPos].pos !== PRE_M) {
+				if (newPos + 1 < end && buf[newPos + 1].cat === ZWJ && newPos > start) {
+					newPos--;
+					continue;
+				}
+			} else newPos = start;
+			break;
+		}
+		if (start < newPos && buf[newPos].pos !== PRE_M) for (let i = newPos; i > start; i--) {
+			if (buf[i - 1].pos !== PRE_M) continue;
+			const old = i - 1;
+			if (old < base && base <= newPos) base--;
+			const [t] = buf.splice(old, 1);
+			buf.splice(newPos, 0, t);
+			mergeClusters(buf, newPos, Math.min(end, base + 1));
+			newPos--;
+		}
+		else for (let i = start; i < base; i++) if (buf[i].pos === PRE_M) {
+			mergeClusters(buf, i, Math.min(end, base + 1));
+			break;
+		}
+	}
+	if (start + 1 < end && buf[start].pos === RA_TO_BECOME_REPH && buf[start].cat === REPHA !== formed(buf[start])) {
+		const afterHalant = () => {
+			let p = start + 1;
+			while (p < base && !isHalant(buf[p])) p++;
+			if (p < base && isHalant(buf[p])) {
+				if (p + 1 < base && isJoiner(buf[p + 1])) p++;
+				return p;
+			}
+		};
+		let target;
+		const rephPos = config.rephPos;
+		if (rephPos !== AFTER_POST) {
+			target = afterHalant();
+			if (target === void 0 && rephPos === AFTER_MAIN) {
+				let p = base;
+				while (p + 1 < end && buf[p + 1].pos <= AFTER_MAIN) p++;
+				if (p < end) target = p;
+			}
+			if (target === void 0 && rephPos === AFTER_SUB) {
+				let p = base;
+				while (p + 1 < end && !(flag(buf[p + 1].pos) & (flag(POST_C) | flag(AFTER_POST) | flag(SMVD)))) p++;
+				if (p < end) target = p;
+			}
+		}
+		target ??= afterHalant();
+		if (target === void 0) {
+			let p = end - 1;
+			while (p > start && buf[p].pos === SMVD) p--;
+			if (isHalant(buf[p])) {
+				for (let i = base + 1; i < p; i++) if (buf[i].cat === M || buf[i].cat === MPST) p--;
+			}
+			target = p;
+		}
+		mergeClusters(buf, start, target + 1);
+		const [reph] = buf.splice(start, 1);
+		buf.splice(target, 0, reph);
+		if (start < base && base <= target) base--;
+	}
+	if (tryPref && base + 1 < end) for (let i = base + 1; i < end; i++) {
+		if ((buf[i].mask & PREF) === 0) continue;
+		if (formed(buf[i])) {
+			let newPos = base;
+			if (!malayalamOrTamil) while (newPos > start && !isOneOf(buf[newPos - 1], flag(M) | flag(MPST) | flag(H))) newPos--;
+			if (newPos > start && isHalant(buf[newPos - 1])) {
+				if (newPos < end && isJoiner(buf[newPos])) newPos++;
+			}
+			mergeClusters(buf, newPos, i + 1);
+			const [t] = buf.splice(i, 1);
+			buf.splice(newPos, 0, t);
+			if (newPos <= base && base < i) base++;
+		}
+		break;
+	}
+	if (buf[start].pos === PRE_M) {
+		const prev = start > 0 ? buf[start - 1] : void 0;
+		if (!prev || !WORDISH_RE.test(String.fromCodePoint(prev.cp))) buf[start].mask |= INIT;
+	}
+}
+//#endregion
+export { hasIndic, shapeIndic, syllableStarts };