reamkit 1.27.0 → 1.29.0

package/README.md

@@ -203,16 +203,17 @@ stencil image masks, constant alpha, and the Type 3 glyphs that are drawings
 rather than letters. It honours the layers a file turns off (§8.11 optional
 content) and the box it says to show (`/CropBox`), and it decides for itself
 whether a file is a document to re-flow or a page to keep — a paper is mostly
-lines, a form is mostly marks — which `pdfLayout` overrides. It reads modern compressed files (cross-reference
+lines, a form is mostly marks — and there is nothing to configure: a caller
+cannot know which of the two it was handed. It reads modern compressed files (cross-reference
 + object streams) and encrypted ones (RC4 / AES — the user password is passed to
 `Ream.parse(bytes, { password })`, defaulting to the permissions-only case); a
 filter it does not carry can be handed to it through
 `Ream.parse(bytes, { filters })`.
 
-A form or a drawing is not a reflowable document, so
-`Ream.parse(bytes, { pdfLayout: 'positional' })` reads the page instead: every
-line stands where its glyphs stand, beside the artwork, the way up the page is
-shown.
+A form or a drawing is not a reflowable document, so the reader keeps it as a
+page instead: every line stands where its glyphs stand, beside the artwork, the
+way up the page is shown. Which of the two readings a file gets it decides
+itself and records in the losses.
 
 **Reads PowerPoint, too.** `Ream.parse` accepts a `.pptx` and turns each slide
 into a page at the deck size — text boxes (with run formatting, alignment,

package/dist/esm/core/converter/ream.d.ts

@@ -21,15 +21,6 @@ export interface ReamParseOptions {
      * encryption (EP14); an encrypted OOXML package always names a password.
      */
     readonly password?: string;
-    /**
-     * PDF only: what to read out of the page. `'flow'` (the default) reconstructs
-     * a re-flowable document — paragraphs and tables in reading order, from the
-     * structure tree where the file has one. `'positional'` keeps the page as a
-     * page: every line stands where its glyphs stand, beside the rules and fills
-     * the page draws. A form or a drawing needs the second; a report to be edited
-     * or converted to markdown needs the first.
-     */
-    readonly pdfLayout?: 'flow' | 'positional';
     /**
      * PDF only: decoders for `/Filter` names the reader does not implement
      * (§7.4). A filter it cannot undo leaves that stream unread — and when the
@@ -38,6 +29,14 @@ export interface ReamParseOptions {
      * carrying one for every filter anyone might write:
      *
      * ```ts
+     * // browser: any wasm/JS decoder you ship — brotli-dec-wasm is ~200 KB
+     * import brotliPromise from 'brotli-dec-wasm';
+     * const brotli = await brotliPromise;
+     * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotli.decompress(b) } });
+     * ```
+     *
+     * ```ts
+     * // node, where the runtime already carries one
      * import { brotliDecompressSync } from 'node:zlib';
      * Ream.parse(pdf, { filters: { BrotliDecode: (b) => brotliDecompressSync(b) } });
      * ```

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

@@ -88,7 +88,6 @@ var Ream = class Ream {
 		if (!reader) throw new Error(`Unrecognized document format (readers: ${readers.map((r) => r.id).join(", ")})`);
 		const { doc, losses } = reader.read(source, {
 			password: options.password,
-			...options.pdfLayout ? { pdfLayout: options.pdfLayout } : {},
 			...options.filters ? { filters: options.filters } : {}
 		});
 		const sheet = doc.kind === "sheet" ? doc : void 0;

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

@@ -1571,10 +1571,12 @@ export interface SectionProperties {
     };
     /**
      * §17.6.22 `w:type` — where the section starts. `continuous` starts it on the
-     * page already in hand rather than a fresh one; everything else (nextPage,
-     * and the odd/even/column variants we do not distinguish) starts a page.
+     * page already in hand rather than a fresh one; `nextPage` on the next sheet;
+     * `oddPage` and `evenPage` on the next sheet of that PARITY, which means a
+     * blank one in between when the count falls wrong. (`nextColumn` is not
+     * distinguished from `nextPage`.)
      */
-    readonly sectionStart?: 'continuous' | 'nextPage';
+    readonly sectionStart?: 'continuous' | 'nextPage' | 'oddPage' | 'evenPage';
     /**
      * §17.6.5 `w:docGrid` — the line grid a `lines`/`linesAndChars` section rules
      * its text onto, as the pitch in points. Every line of the section's text is

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

@@ -6,5 +6,6 @@ export type { FontVariant, FontBytesByVariant } from './font-registry.js';
 export { pickVariant } from './font-registry.js';
 export { parseGposKerning, parseGsubLigatures, shapeText } from './opentype-layout.js';
 export type { KerningMap, LigatureMap, ShapedRun } from './opentype-layout.js';
+export { hasSubstitutable, lettersForLigature, substituteLetters } from './ligatures.js';
 export { createFontMeasure } from './measure.js';
 export type { FontMeasure } from './measure.js';

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

@@ -0,0 +1,17 @@
+/**
+ * The letters a character stands for, for a character nothing can draw.
+ *
+ * @param cp The code point.
+ * @returns The letters, or `undefined` when the character is a letter itself.
+ */
+export declare function substituteLetters(cp: number): string | undefined;
+/** Whether any code point of `text` is one {@link substituteLetters} answers for. */
+export declare function hasSubstitutable(text: string): boolean;
+/**
+ * The letters a LIGATURE stands for, for the one place that asks only about
+ * those: the `/ToUnicode` a drawn ligature glyph is stated by.
+ *
+ * @param cp The code point.
+ * @returns The letters, or `undefined` when it is not one of these ligatures.
+ */
+export declare function lettersForLigature(cp: number): string | undefined;

package/dist/esm/core/font/ligatures.js

@@ -0,0 +1,49 @@
+//#region src/core/font/ligatures.ts
+/**
+* The letters a character stands for, for a character nothing can draw.
+*
+* @param cp The code point.
+* @returns The letters, or `undefined` when the character is a letter itself.
+*/
+function substituteLetters(cp) {
+	const ligature = LIGATURE_LETTERS.get(cp);
+	if (ligature !== void 0) return ligature;
+	if (cp >= 119808 && cp <= 120831) return decomposed(cp);
+	if (cp >= 8448 && cp <= 8527) {
+		const letters = decomposed(cp);
+		return letters?.length === 1 ? letters : void 0;
+	}
+}
+/** Whether any code point of `text` is one {@link substituteLetters} answers for. */
+function hasSubstitutable(text) {
+	for (const ch of text) if (substituteLetters(ch.codePointAt(0)) !== void 0) return true;
+	return false;
+}
+/**
+* The letters a LIGATURE stands for, for the one place that asks only about
+* those: the `/ToUnicode` a drawn ligature glyph is stated by.
+*
+* @param cp The code point.
+* @returns The letters, or `undefined` when it is not one of these ligatures.
+*/
+function lettersForLigature(cp) {
+	return LIGATURE_LETTERS.get(cp);
+}
+/** U+FB00..FB06 — `ſt` opens with a long s, which is an s. */
+var LIGATURE_LETTERS = new Map([
+	[64256, "ff"],
+	[64257, "fi"],
+	[64258, "fl"],
+	[64259, "ffi"],
+	[64260, "ffl"],
+	[64261, "st"],
+	[64262, "st"]
+]);
+/** What Unicode says the character is a form of, or `undefined` if nothing. */
+function decomposed(cp) {
+	const ch = String.fromCodePoint(cp);
+	const base = ch.normalize("NFKD");
+	return base === ch ? void 0 : base;
+}
+//#endregion
+export { hasSubstitutable, lettersForLigature, substituteLetters };

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

@@ -63,7 +63,8 @@ export interface ParsedTtf {
 /**
  * Parse TrueType / OpenType font bytes into a {@link ParsedTtf}.
  *
- * @param raw The font bytes (sfnt: TrueType `0x00010000` or OpenType-CFF `OTTO`).
+ * @param raw The font bytes (sfnt: TrueType `0x00010000` or `'true'`, or
+ *            OpenType-CFF `OTTO`).
  * @returns The parsed metrics, mappings and layout tables.
  * @throws Error when the bytes are not a TrueType or OpenType font.
  */

package/dist/esm/core/font/ttf-parser.js

@@ -4,16 +4,25 @@ import { parseGposKerning, parseGsubArabicForms, parseGsubLigatures } from "./op
 var SFNT_TRUETYPE = 65536;
 var SFNT_OPENTYPE_CFF = 1330926671;
 /**
+* `'true'` — Apple's own sfnt tag, and as much a TrueType font as `0x00010000`.
+* Rejected outright, the reader could not read the program a file embedded and
+* so could not say what its glyphs were: complex_ttf_font.pdf,
+* PDFJS-7562-reduced.pdf and arial_unicode_en_cidfont.pdf each carry one and
+* each reconstructed to a blank page.
+*/
+var SFNT_APPLE_TRUE = 1953658213;
+/**
 * Parse TrueType / OpenType font bytes into a {@link ParsedTtf}.
 *
-* @param raw The font bytes (sfnt: TrueType `0x00010000` or OpenType-CFF `OTTO`).
+* @param raw The font bytes (sfnt: TrueType `0x00010000` or `'true'`, or
+*            OpenType-CFF `OTTO`).
 * @returns The parsed metrics, mappings and layout tables.
 * @throws Error when the bytes are not a TrueType or OpenType font.
 */
 function parseTtf(raw) {
 	const r = new BigEndianReader(raw);
 	const sfntVersion = r.u32();
-	if (sfntVersion !== SFNT_TRUETYPE && sfntVersion !== SFNT_OPENTYPE_CFF) throw new Error(`Not a TrueType or OpenType font (sfntVersion=0x${sfntVersion.toString(16).padStart(8, "0")})`);
+	if (sfntVersion !== SFNT_TRUETYPE && sfntVersion !== SFNT_OPENTYPE_CFF && sfntVersion !== SFNT_APPLE_TRUE) throw new Error(`Not a TrueType or OpenType font (sfntVersion=0x${sfntVersion.toString(16).padStart(8, "0")})`);
 	const numTables = r.u16();
 	r.skip(6);
 	const tables = /* @__PURE__ */ new Map();

package/dist/esm/core/fonts/remote-fonts.d.ts

@@ -11,7 +11,7 @@ export type FamilyKey = 'arimo' | 'tinos' | 'cousine' | 'carlito' | 'caladea';
  * only in the regular weight: Noto Sans SC is ten megabytes, and a bold run in
  * it is better stroked (see `SyntheticFace`) than downloaded four times over.
  */
-export type ScriptKey = 'jp' | 'kr' | 'sc' | 'arabic' | 'hebrew' | 'thai' | 'symbols';
+export type ScriptKey = 'jp' | 'kr' | 'sc' | 'arabic' | 'hebrew' | 'thai' | 'symbols1' | 'symbols2';
 /** Either kind of substitute — a Latin family or a per-script face. */
 export type SubstituteKey = FamilyKey | ScriptKey;
 /** Whether a substitute key names a writing system rather than a Latin family. */

package/dist/esm/core/fonts/remote-fonts.js

@@ -31,7 +31,11 @@ var SCRIPTS = {
 		pkg: "noto-sans-thai",
 		file: "NotoSansThai"
 	},
-	symbols: {
+	symbols1: {
+		pkg: "noto-sans-symbols",
+		file: "NotoSansSymbols"
+	},
+	symbols2: {
 		pkg: "noto-sans-symbols-2",
 		file: "NotoSansSymbols2"
 	}
@@ -102,6 +106,47 @@ var MONO = new Set([
 	"dejavu sans mono",
 	"monospace"
 ]);
+var STEMS = [
+	["latinmodernroman", "tinos"],
+	["latinmodernmath", "tinos"],
+	["latinmodernmono", "cousine"],
+	["latinmodernsans", "arimo"],
+	["lmroman", "tinos"],
+	["lmmath", "tinos"],
+	["lmmono", "cousine"],
+	["lmsans", "arimo"],
+	["cmbx", "tinos"],
+	["cmcsc", "tinos"],
+	["cmti", "tinos"],
+	["cmsl", "tinos"],
+	["cmmi", "tinos"],
+	["cmsy", "tinos"],
+	["cmss", "arimo"],
+	["cmtt", "cousine"],
+	["cmr", "tinos"],
+	["nimbusrom", "tinos"],
+	["nimbussan", "arimo"],
+	["nimbusmon", "cousine"],
+	["urwpalladio", "tinos"],
+	["urwbookman", "tinos"],
+	["centuryschlbk", "tinos"],
+	["centuryschoolbook", "tinos"],
+	["newcenturyschlbk", "tinos"],
+	["bookman", "tinos"],
+	["palatino", "tinos"],
+	["utopia", "tinos"],
+	["charter", "tinos"],
+	["baskerville", "tinos"],
+	["caslon", "tinos"],
+	["minionpro", "tinos"],
+	["stoneserif", "tinos"],
+	["stonesans", "arimo"],
+	["myriadpro", "arimo"]
+];
+/** The family a name STARTS with, for the families named by stem and size. */
+function familyFromStem(name) {
+	for (const [stem, key] of STEMS) if (name.startsWith(stem)) return key;
+}
 var WEIGHT_WORDS = new Map([
 	["black", "bold"],
 	["heavy", "bold"],
@@ -159,7 +204,7 @@ function resolveFamilyStyle(name) {
 	];
 	let key = "arimo";
 	for (const n of tries) {
-		const found = EXACT[n] ?? (MONO.has(n) ? "cousine" : SERIF.has(n) ? "tinos" : void 0);
+		const found = EXACT[n] ?? (MONO.has(n) ? "cousine" : SERIF.has(n) ? "tinos" : void 0) ?? familyFromStem(n.replace(/[^a-z]/gu, ""));
 		if (found) {
 			key = found;
 			break;

package/dist/esm/core/fonts/scripts.js

@@ -33,27 +33,27 @@ var RANGES = [
 	[
 		8592,
 		8703,
-		"symbols"
+		"symbols1"
 	],
 	[
 		8960,
 		9215,
-		"symbols"
+		"symbols1"
 	],
 	[
 		9312,
 		9471,
-		"symbols"
+		"symbols1"
 	],
 	[
 		9472,
 		10175,
-		"symbols"
+		"symbols2"
 	],
 	[
 		11008,
 		11263,
-		"symbols"
+		"symbols2"
 	],
 	[
 		12288,
@@ -149,6 +149,11 @@ function scriptsInFlow(flow) {
 				marks.add("han");
 				continue;
 			}
+			if (key === "symbols1" || key === "symbols2") {
+				scripts.add("symbols1");
+				scripts.add("symbols2");
+				continue;
+			}
 			scripts.add(key);
 		}
 	};

package/dist/esm/excel/header-footer.js

@@ -53,20 +53,65 @@ function applyHeaderTint(hex, amount, darken) {
 function buildHeaderFooterContent(formatString, sheetName, scale = 1, basePt = DEFAULT_HEADER_PT, fileName, themePalette, now) {
 	const regions = parseHeaderFooterString(formatString, sheetName, scale, basePt, fileName, themePalette, now);
 	const out = [];
-	const para = (runs, alignment) => {
-		for (const line of splitLines(runs)) if (line.length > 0) out.push({
+	const lines = {
+		left: splitLines(regions.left),
+		center: splitLines(regions.center),
+		right: splitLines(regions.right)
+	};
+	const filled = (region) => lines[region].filter((line) => line.length > 0).length;
+	if ((filled("left") > 0 ? 1 : 0) + (filled("center") > 0 ? 1 : 0) + (filled("right") > 0 ? 1 : 0) <= 1) {
+		const para = (runs, alignment) => {
+			for (const line of splitLines(runs)) if (line.length > 0) out.push({
+				kind: "paragraph",
+				paragraph: {
+					properties: { alignment },
+					runs: line
+				}
+			});
+		};
+		para(regions.left, "left");
+		para(regions.center, "center");
+		para(regions.right, "right");
+		return out;
+	}
+	const deep = Math.max(lines.left.length, lines.center.length, lines.right.length);
+	for (let i = 0; i < deep; i++) {
+		const left = lines.left[i] ?? [];
+		const center = lines.center[i] ?? [];
+		const right = lines.right[i] ?? [];
+		if (left.length + center.length + right.length === 0) continue;
+		const runs = [...left];
+		if (center.length > 0) runs.push(TAB_RUN, ...center);
+		if (right.length > 0) runs.push(TAB_RUN, ...right);
+		out.push({
 			kind: "paragraph",
 			paragraph: {
-				properties: { alignment },
-				runs: line
+				properties: { tabs: HEADER_STOPS },
+				runs
 			}
 		});
-	};
-	para(regions.left, "left");
-	para(regions.center, "center");
-	para(regions.right, "right");
+	}
 	return out;
 }
+/** The tab a header's regions are separated by. */
+var TAB_RUN = {
+	text: "	",
+	properties: {}
+};
+/**
+* §17.3.1.38 — the two stops a header's regions stand on: the middle of the
+* band and its far edge, both stated against the band itself rather than at a
+* distance, since only the layout knows how wide the band is.
+*/
+var HEADER_STOPS = [{
+	positionPt: pt(0),
+	relativeTo: "center",
+	alignment: "center"
+}, {
+	positionPt: pt(0),
+	relativeTo: "right",
+	alignment: "right"
+}];
 /**
 * Break a region's runs at the line breaks Excel allows inside one — a header
 * region is not necessarily one line.

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

@@ -1,6 +1,7 @@
 import { resolveFamilyStyle } from "../core/fonts/remote-fonts.js";
 import { scriptForCodepoint } from "../core/fonts/scripts.js";
 import { shapeText } from "../core/font/opentype-layout.js";
+import { hasSubstitutable, substituteLetters } from "../core/font/ligatures.js";
 import { createFontMeasure } from "../core/font/measure.js";
 import { halfPtToPt, pt } from "../core/ir/units.js";
 import { ResourceStore } from "../core/ir/resources.js";
@@ -2434,6 +2435,40 @@ function fallbackFaceKey(options, cp, bold, italic) {
 	}
 }
 /**
+* A character no face on hand can draw, set as the letters it stands for.
+*
+* `ff` (U+FB00) is one glyph for two f's — a shape of the FACE, not a letter of
+* the alphabet, and most faces carry no such code point at all: they form the
+* ligature from `ff` through their own `liga` table. `𝑝` (U+1D45D) is a lower
+* case p set in italic, given a code point of its own so that mathematics can
+* name a variable in plain text; no ordinary face carries that either. So the
+* run's own face drew nothing, no other loaded face answered, and the character
+* went out as a box or as nothing at all: bug1873345.pdf reads "different" and
+* we set "di erent", bug1529502.pdf reads "p ← trim(p)" and we set "□ ← □".
+* The letters are the same text — the ligature the face is free to form again,
+* the slant is lost, and both beat a box.
+*
+* Only where nobody can draw the character itself: one a face DOES carry is
+* drawn as written.
+*
+* @param options  The render options (the loaded registries).
+* @param primary  The run's own face.
+* @param resolved Its resolved properties (weight and slant).
+* @param text     The run's text.
+* @returns The text to set, which is `text` itself unless something was undrawable.
+*/
+function drawableText(options, primary, resolved, 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 || primary.glyphForCodepoint(cp) !== 0 || fallbackFaceKey(options, cp, resolved.bold, resolved.italic) !== void 0;
+		out += drawable ? ch : letters;
+	}
+	return out;
+}
+/**
 * §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`
@@ -2580,7 +2615,7 @@ function collectFontResources(body, headersFooters, options, imageResources) {
 			};
 			used.set(fontKey, bucket);
 		}
-		const text = run.listMarker === true ? markerText(run.text, parsed) : run.text;
+		const text = drawableText(options, parsed, resolved, run.listMarker === true ? markerText(run.text, parsed) : run.text);
 		for (const span of faceSpans(options, {
 			fontKey,
 			parsed
@@ -3008,9 +3043,16 @@ function tokenizeParagraph(paragraph, options, fontResources, imageResources, co
 		const { fontKey, synthetic } = runFontKeyAndParsed(options, resolvedRun.fontFamily.ascii, resolvedRun.bold, resolvedRun.italic);
 		const script = SCRIPT_OFFSET[resolvedRun.verticalAlign] ?? 0;
 		const own = lookupFont(fontResources, fontKey);
-		const faceFor = facesForRun(options, fontResources, own.parsed, resolvedRun, run.text);
+		const drawn = (() => {
+			const text = drawableText(options, own.parsed, resolvedRun, run.text);
+			return text === run.text ? run : {
+				...run,
+				text
+			};
+		})();
+		const faceFor = facesForRun(options, fontResources, own.parsed, resolvedRun, drawn.text);
 		return {
-			run,
+			run: drawn,
 			resolvedRun,
 			font: own,
 			...faceFor ? { faceFor } : {},
@@ -5114,6 +5156,14 @@ function paginateSections(blocks, sectionCtxs, builder, defaultLang = "en-US", n
 			}
 			if (asm.pageHasContent() || asm.pageInSection === 0) asm.flushPage(true);
 			else asm.dropPage();
+			const opening = sectionCtxs[asm.secIdx + 1]?.properties;
+			const wants = opening?.sectionStart;
+			if (wants === "oddPage" || wants === "evenPage") {
+				if ((opening?.pageNumberStart ?? asm.pageNumber) % 2 === 1 !== (wants === "oddPage")) {
+					asm.cursorY = asm.ctx.pageHeight - asm.ctx.marginTop;
+					asm.flushPage(true);
+				}
+			}
 			asm.secIdx++;
 			asm.ctx = sectionCtxs[asm.secIdx];
 			asm.restartPageNumbers(asm.ctx);

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

@@ -1,4 +1,5 @@
 import { glyphClosure, subsetTtf } from "../core/font/ttf-subset.js";
+import { lettersForLigature } from "../core/font/ligatures.js";
 import { createFontMeasure } from "../core/font/measure.js";
 import { deflatedStream, dict, name, ref } from "./objects.js";
 //#region src/pdf/cid-font.ts
@@ -109,6 +110,22 @@ function consecutiveRuns(ids) {
 	}
 	return runs;
 }
+/**
+* How much a code point says about the character a glyph stands for.
+*
+* A presentation form is a shape — the ligature two letters make, the form a
+* letter takes where it joins — but a shape that names its letters. A
+* private-use code is a font's own numbering and names nothing at all. A glyph
+* several codes reach keeps the one that says the most.
+*
+* @param cp The code point.
+* @returns 0 for a character, 1 for a presentation form, 2 for private use.
+*/
+function codeRank(cp) {
+	if (cp >= 57344 && cp <= 63743) return 2;
+	if (cp >= 64256 && cp <= 65023 || cp >= 65136 && cp <= 65279) return 1;
+	return 0;
+}
 function buildToUnicodeCMap(parsed, subsetGids) {
 	const inSubset = subsetGids ? new Set(subsetGids) : void 0;
 	const gidToCps = /* @__PURE__ */ new Map();
@@ -116,30 +133,40 @@ function buildToUnicodeCMap(parsed, subsetGids) {
 	for (let cp = 9; cp <= 65535; cp++) {
 		if (cp >= 55296 && cp <= 57343) continue;
 		const gid = parsed.glyphForCodepoint(cp);
-		if (gid === 0 || gidToCps.has(gid)) continue;
+		if (gid === 0) continue;
+		const had = gidToCps.get(gid);
+		if (had) {
+			if (had.length === 1 && codeRank(cp) < codeRank(had[0])) gidToCps.set(gid, [cp]);
+			continue;
+		}
 		gidToCps.set(gid, [cp]);
 		order.push(gid);
 	}
+	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)));
+	}
 	let changed = true;
 	while (changed) {
 		changed = false;
 		for (const [key, ligGid] of parsed.ligatures) {
-			if (gidToCps.has(ligGid)) continue;
+			const have = gidToCps.get(ligGid);
+			if (have && !(have.length === 1 && codeRank(have[0]) > 0)) continue;
 			const cps = [];
 			let ok = true;
 			for (const comp of key.split(",")) {
 				const c = gidToCps.get(Number(comp));
-				if (!c) {
+				if (!c || c === have) {
 					ok = false;
 					break;
 				}
 				cps.push(...c);
 			}
-			if (ok && cps.length > 0) {
-				gidToCps.set(ligGid, cps);
-				order.push(ligGid);
-				changed = true;
-			}
+			if (!ok || cps.length === 0) continue;
+			if (have?.join(",") === cps.join(",")) continue;
+			gidToCps.set(ligGid, cps);
+			if (!have) order.push(ligGid);
+			changed = true;
 		}
 	}
 	const pairs = order.filter((g) => inSubset === void 0 || inSubset.has(g)).map((g) => [g, gidToCps.get(g)]).sort((a, b) => a[0] - b[0]);