@sushichan044/kg-core 0.8.0 → 0.9.1

package/README.md

@@ -84,10 +84,18 @@ a closing bracket, comma, or full stop, a quarter em on either side of a middle
 a quarter em between Japanese and a numeral, unit symbol, or Western character, and
 solid where two of those punctuation marks meet.
 
-An overflowing line is answered by reducing that space or by hanging a comma or full
-stop; a short line is answered by opening up space where JLReq 3.8.4 and appendix 表6
-allow it — the Japanese-to-Western quarter em first, up to a half, then a solid pair
-between kana, kanji, and the marks that go with them, up to a quarter. Space around
+A western word space is not a character with a box but an アキ of its own: a third em
+by rule rather than by measurement, nothing at all at a line head or a line end, and
+the first _visible_ space either direction of the adjustment reaches for — only the
+line-end space, which the reader cannot see at all, is spent ahead of it. It leaves the
+composer as a `glue` item carrying the source text it came from.
+
+An overflowing line is answered by reducing the space between characters, stage by
+stage, or by hanging a comma or full stop; a short line is answered by opening up space
+where JLReq 3.8.4 and appendix 表6
+allow it — the word space first, up to a half, then the Japanese-to-Western quarter em,
+also up to a half, then a solid pair between kana, kanji, and the marks that go with
+them, up to a quarter. Space around
 brackets, commas, full stops, middle dots, hyphens, and an ideographic space is never
 opened up. A line that admits none of these is forced. The choice is made for the
 paragraph rather than line by line,
@@ -95,11 +103,33 @@ minimizing in order the number of forced lines, then stretched, then hanging, th
 shrunk lines that spent visible space. Which space may be reduced, and in which
 order, follows JLReq 3.8.3 and appendix 表3: the space at the line end goes first and
 costs the paragraph nothing, because it is invisible once that character lands there;
-then a middle dot's quarters, then the half em before an opening bracket or after a
+then the word space, down to a quarter em; then a middle dot's quarters, then the half
+em before an opening bracket or after a
 closing bracket or comma, then the Japanese-to-Western quarter down to an eighth. The
 half em after a mid-line full stop marks the end of a sentence and is never reduced,
 and neither is the half em that keeps a line-head opening bracket off the edge.
 
+JLReq puts the word space ahead of the line end; the composer swaps the two, because
+a stage here says how visible an adjustment is and the line end is the only space the
+reader cannot see at all.
+
+The アキ at a line end is the one exception to spending a space in part. JLReq 3.1.9
+admits the full アキ or ベタ組 and forbids anything between, so a line whose overflow is
+smaller than it leaves it whole and finds the difference elsewhere — or breaks
+elsewhere. A 中点類 at a line end gives up the quarter em before it together with the
+quarter after, as one amount.
+
+Every stage is spent 文字サイズ比で均等に, as JLReq 3.8.3 and 3.8.4 both put it: the amount
+is split across all the spaces of that stage in proportion to what each of them can
+give, rather than taken out of the earliest space until it runs dry. A stage opens
+only once every stage before it is spent out.
+
+JLReq 3.1.5 states the white before a line-head opening bracket as a pair of amounts:
+one for 改行行頭, the head of a line that starts a paragraph, and one for 折返し行頭, the
+head of a line the composer turned over. The specification lists three such pairs, and
+the composer takes the one Japanese novels are set with — scheme ③: a half em at
+改行行頭, and 天付き, flush against the edge, at 折返し行頭.
+
 The composer also owns Japanese line-start and line-end restrictions, inseparable
 punctuation, question/exclamation gap suppression, and ruby placement.
 

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, l as ManuscriptDiagnostic, o as graphemeSegmenter, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-CROZLBqt.mjs";
+import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-CtovfhET.mjs";
 import { n as assertNever, t as describeCause } from "./describe-cause-BV8mZ3Um.mjs";
 import * as v from "valibot";
 const Rejection = { schema: readonlyObject({ reason: v.string() }) };

package/dist/{novel-composer-CROZLBqt.mjs → novel-composer-CtovfhET.mjs}

@@ -337,14 +337,17 @@ function classify({ value, presentation }) {
 * The stages JLReq 3.8.3 spends inter-character space in, as glue priorities: the lower the number,
 * the earlier the paragraph optimizer takes it.
 *
-* JLReq's own first stage is the western word space (cl-26), which is absent here because reducing
-* it means resizing the space's own advance rather than a space between two characters.
+* JLReq puts the western word space first and the line-end reduction second; this profile swaps the
+* two, because a priority here says how visible an adjustment is rather than where 3.8.3's list
+* puts it. Priority 0 is capacity the paragraph optimizer spends for nothing, and a line that spent
+* only priority 0 reads as tightly set as an unadjusted one. That is true of the line end and of
+* nothing else: the half em after a closing bracket, full stop or comma — and the quarter em after
+* a middle dot — falls outside the text area once that character sits at the line end, so taking it
+* changes nothing on the page (3.1.9). A 欧文間隔 sits between two words the reader is looking at, so
+* narrowing it does change the page. Spending the invisible space first can only leave the word
+* spaces nearer their 三分アキ than JLReq's order would, never further from it.
 *
-* The line-end stage is priority 0, which the optimizer also charges nothing for. JLReq 3.1.9 is
-* what allows that: the half em after a closing bracket, full stop or comma — and the quarter em
-* after a middle dot — cannot be seen once that character sits at the line end. JLReq orders it
-* second rather than first, but only after the word space this profile does not adjust at all.
-* Stages two and three are one priority here because a line has a single line end, so the two never
+* Stages two and three are one priority because a line has a single line end, so the two never
 * compete.
 */
 const REDUCTION_STAGE = {
@@ -353,37 +356,47 @@ const REDUCTION_STAGE = {
 	*/
 	lineEnd: 0,
 	/**
+	* Stage 1: the western word space, from its 三分アキ down to a 四分アキ.
+	*/
+	wordSpace: 1,
+	/**
 	* Stage 4: the quarter em on either side of a mid-line middle dot.
 	*/
-	middleDot: 1,
+	middleDot: 2,
 	/**
 	* Stage 5: the half em before an opening bracket and after a closing bracket or comma.
 	*/
-	punctuation: 2,
+	punctuation: 3,
 	/**
 	* Stage 6: the quarter em between Japanese and a numeral, unit symbol or western character.
 	*/
-	mixedText: 3
+	mixedText: 4
 };
 /**
 * The stages JLReq 3.8.4 adds inter-character space in, as glue priorities on the same reading as
 * {@link REDUCTION_STAGE}: the lower the number, the earlier the paragraph optimizer takes it. A
 * line is either reduced or expanded, never both, so the two scales never meet.
 *
-* Stage 1 is the western word space (cl-26), absent for the same reason it is absent from the
-* reduction stages. Stage 4 spreads whatever a、b and c could not absorb across every character gap
-* that is not unbreakable, and is deliberately not implemented: it would justify every line that
-* currently falls short, which reads as prose combed out to the margin rather than a novel.
+* Stage 4 spreads whatever a、b and c could not absorb across every character gap that is not
+* unbreakable, and is deliberately not implemented: it would justify every line that currently
+* falls short, which reads as prose combed out to the margin rather than a novel.
+*
+* Nothing here takes priority 0. Expanding is always visible, and priority 0 means an adjustment
+* the optimizer is charged nothing for.
 */
 const EXPANSION_STAGE = {
+	/**
+	* Stage 1: the western word space, from its 三分アキ up to a 二分アキ.
+	*/
+	wordSpace: 1,
 	/**
 	* Stage 2: the quarter em between Japanese and a numeral, unit symbol or western character.
 	*/
-	mixedText: 1,
+	mixedText: 2,
 	/**
 	* Stage 3: everywhere else 表6 admits, from solid up to a quarter em.
 	*/
-	solid: 2
+	solid: 3
 };
 /**
 * 無印 in 表1 with no colour in 表6: the pair is set solid and line adjustment leaves it alone.
@@ -400,7 +413,8 @@ const SOLID_EXPANDABLE = {
 	naturalWidthEm: 0,
 	stretch: {
 		priority: EXPANSION_STAGE.solid,
-		amountEm: .25
+		amountEm: .25,
+		granularity: "continuous"
 	}
 };
 /**
@@ -411,7 +425,8 @@ const HALF = {
 	naturalWidthEm: .5,
 	shrink: {
 		priority: REDUCTION_STAGE.punctuation,
-		amountEm: .5
+		amountEm: .5,
+		granularity: "continuous"
 	}
 };
 /**
@@ -429,7 +444,8 @@ const QUARTER = {
 	naturalWidthEm: .25,
 	shrink: {
 		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .25
+		amountEm: .25,
+		granularity: "continuous"
 	}
 };
 /**
@@ -448,11 +464,13 @@ const MIXED_TEXT_QUARTER = {
 	naturalWidthEm: .25,
 	shrink: {
 		priority: REDUCTION_STAGE.mixedText,
-		amountEm: .125
+		amountEm: .125,
+		granularity: "continuous"
 	},
 	stretch: {
 		priority: EXPANSION_STAGE.mixedText,
-		amountEm: .25
+		amountEm: .25,
+		granularity: "continuous"
 	}
 };
 /**
@@ -464,7 +482,8 @@ const UNIT_SYMBOL_QUARTER = {
 	naturalWidthEm: .25,
 	shrink: {
 		priority: REDUCTION_STAGE.mixedText,
-		amountEm: .125
+		amountEm: .125,
+		granularity: "continuous"
 	}
 };
 /**
@@ -475,7 +494,8 @@ const TWO_QUARTERS = {
 	naturalWidthEm: .5,
 	shrink: {
 		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .5
+		amountEm: .5,
+		granularity: "continuous"
 	}
 };
 /**
@@ -486,7 +506,8 @@ const FIXED_HALF_AND_QUARTER = {
 	naturalWidthEm: .75,
 	shrink: {
 		priority: REDUCTION_STAGE.middleDot,
-		amountEm: .25
+		amountEm: .25,
+		granularity: "continuous"
 	}
 };
 /**
@@ -501,7 +522,8 @@ const HALF_AND_QUARTER = {
 	naturalWidthEm: .75,
 	shrink: {
 		priority: REDUCTION_STAGE.punctuation,
-		amountEm: .75
+		amountEm: .75,
+		granularity: "continuous"
 	}
 };
 /**
@@ -512,6 +534,40 @@ const DASH_JOINT = {
 	naturalWidthEm: 0
 };
 /**
+* 欧文間隔（cl-26）の三分アキ. JLReq states the western word space as a third em by rule rather than by
+* measurement, and makes it the first space a line adjustment reaches for: down to a 四分アキ when the
+* line is over (3.8.3 a), up to a 二分アキ when it is short (3.8.4 a).
+*
+* The two capacities are written as differences from the limits rather than as `1/12` and `1/6`,
+* because a third of an em is not representable in binary while the limits JLReq states are: this
+* way `naturalWidthEm - shrink.amountEm` is exactly 0.25 and `naturalWidthEm + stretch.amountEm`
+* exactly 0.5.
+*/
+const WORD_SPACE = {
+	kind: "glue",
+	naturalWidthEm: 1 / 3,
+	shrink: {
+		priority: REDUCTION_STAGE.wordSpace,
+		amountEm: 1 / 3 - 1 / 4,
+		granularity: "continuous"
+	},
+	stretch: {
+		priority: EXPANSION_STAGE.wordSpace,
+		amountEm: 1 / 2 - 1 / 3,
+		granularity: "continuous"
+	}
+};
+/**
+* 表1 注13 と 表3 注4: a word space at a line head or a line end has no width and is no adjustment
+* opportunity, since the white would fall outside the text area where no reader can see it. 注13
+* adds ただし，この部分が移動し，これとは異なる配置になった場合は，欧文間隔（cl-26）の空き量を確保する — which is why the answer is given per
+* candidate line and not once per source line.
+*/
+const EDGE_WORD_SPACE = {
+	kind: "glue",
+	naturalWidthEm: 0
+};
+/**
 * The classes that take a quarter em against a numeral, unit symbol or western character (3.2.6).
 * Dividing punctuation is on the list in that direction only, because the space before a `？` or `！`
 * is solid (3.1.6).
@@ -807,6 +863,10 @@ const defaultJapaneseTypesettingProfile = {
 	* trailing half of its em, a middle dot in the centre, and the rest in the leading half.
 	*/
 	boxMetrics: (characterClass, measuredAdvanceEm) => {
+		if (characterClass === "cl-26") return {
+			advanceEm: 0,
+			renderOffsetEm: 0
+		};
 		const advanceEm = HALF_EM_CLASSES.has(characterClass) ? Math.min(.5, measuredAdvanceEm) : measuredAdvanceEm;
 		const inkOverhangEm = measuredAdvanceEm - advanceEm;
 		return {
@@ -815,16 +875,18 @@ const defaultJapaneseTypesettingProfile = {
 		};
 	},
 	pairSpacing,
+	spacingCharacter: (characterClass, position) => characterClass !== "cl-26" ? null : position === "mid-line" ? WORD_SPACE : EDGE_WORD_SPACE,
 	/**
-	* An opening bracket at the line head keeps a half em of white, so a line of dialogue starts one
-	* half em in rather than tight against the edge. JLReq 3.1.5 lists three schemes for that white
-	* and 表1 注17 sets solid as the principle; the half em is the variant the publishers of Japanese
-	* novels use for a line that begins a paragraph.
+	* The white before an opening bracket at a line head. JLReq 3.1.5 pairs 改行行頭 with 折返し行頭 and lists
+	* three schemes for the two together: ① 全角アキ and 天付き, ② 全角半アキ and 二分アキ, ③ 二分アキ and 天付き. This
+	* profile takes ③, the scheme 講談社, 新潮社, 文藝春秋, 中央公論新社 and 筑摩書房 set novels with; ① is what JIS X
+	* 4051 and 岩波書店 use. A line of dialogue therefore starts one half em in when it opens a
+	* paragraph, and flush against the edge when the composer turned it over.
 	*
 	* The white is not shrinkable. 表3 excludes the line head from line adjustment altogether, and
 	* shrinking it is exactly what pushed a line-head bracket flush against the edge in #94.
 	*/
-	lineStartSpacing: (first) => first === "cl-01" ? {
+	lineStartSpacing: (first, lineHead) => first === "cl-01" && lineHead === "paragraph-start" ? {
 		kind: "glue",
 		naturalWidthEm: .5
 	} : null,
@@ -832,21 +894,33 @@ const defaultJapaneseTypesettingProfile = {
 	* The half em trailing a closing bracket, full stop or comma at the line end, and the quarter em
 	* trailing a middle dot there (JLReq 3.1.9). Priority 0: spending it changes nothing the reader
 	* can see.
+	*
+	* Both are all-or-nothing. 3.1.9 admits the full アキ or ベタ組 and forbids anything in between, so a
+	* line whose overflow is smaller than the アキ has to find the difference somewhere else — or break
+	* elsewhere. A line-end middle dot takes the quarter before it into the same amount (表3 注5).
 	*/
 	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
-		kind: "glue",
-		naturalWidthEm: .5,
-		shrink: {
-			priority: REDUCTION_STAGE.lineEnd,
-			amountEm: .5
-		}
+		spacing: {
+			kind: "glue",
+			naturalWidthEm: .5,
+			shrink: {
+				priority: REDUCTION_STAGE.lineEnd,
+				amountEm: .5,
+				granularity: "all-or-nothing"
+			}
+		},
+		absorbsPrecedingEm: 0
 	} : last === "cl-05" ? {
-		kind: "glue",
-		naturalWidthEm: .25,
-		shrink: {
-			priority: REDUCTION_STAGE.lineEnd,
-			amountEm: .25
-		}
+		spacing: {
+			kind: "glue",
+			naturalWidthEm: .25,
+			shrink: {
+				priority: REDUCTION_STAGE.lineEnd,
+				amountEm: .25,
+				granularity: "all-or-nothing"
+			}
+		},
+		absorbsPrecedingEm: .25
 	} : null,
 	breakPenalty,
 	/**
@@ -862,6 +936,13 @@ const EPSILON = 1e-9;
 * Spending capacity at this priority changes nothing the reader can see.
 */
 const FREE_SHRINK_PRIORITY = 0;
+/**
+* Interleave the two kinds onto one number so the allocator can key a plain `Map` without building
+* a string per boundary — this runs once per adjustment unit of every candidate line.
+*/
+function slotKey(slot) {
+	return slot.kind === "gap" ? slot.boundary * 2 : slot.index * 2 + 1;
+}
 function skipSourceGaps(atoms, start) {
 	let cursor = start;
 	while (atoms[cursor]?.sourceGap === true) cursor += 1;
@@ -870,14 +951,31 @@ function skipSourceGaps(atoms, start) {
 function previousVisible(atoms, end) {
 	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
 }
-function opportunities(atoms, classes, start, end, profile) {
+function opportunities(atoms, classes, start, end, profile, lineHead) {
 	const result = [];
 	const firstClass = classes[start];
-	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass);
+	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass, lineHead);
 	if (startSpacing !== null) result.push({
-		boundary: start,
-		spacing: startSpacing
+		slot: {
+			kind: "gap",
+			boundary: start
+		},
+		spacing: startSpacing,
+		absorbsPrecedingEm: 0
 	});
+	for (let index = start; index < end; index += 1) {
+		const characterClass = classes[index];
+		if (characterClass === void 0 || atoms[index]?.sourceGap === true) continue;
+		const spacing = profile.spacingCharacter(characterClass, index === start || index === end - 1 ? "line-edge" : "mid-line");
+		if (spacing !== null) result.push({
+			slot: {
+				kind: "character",
+				index
+			},
+			spacing,
+			absorbsPrecedingEm: 0
+		});
+	}
 	for (let right = start + 1; right < end; right += 1) {
 		const leftAtom = atoms[right - 1];
 		const rightAtom = atoms[right];
@@ -885,73 +983,203 @@ function opportunities(atoms, classes, start, end, profile) {
 		const rightClass = classes[right];
 		if (leftAtom === void 0 || rightAtom === void 0 || leftClass === void 0 || rightClass === void 0 || leftAtom.sourceGap || rightAtom.sourceGap || !leftAtom.pairSpacingAfter) continue;
 		result.push({
-			boundary: right,
-			spacing: profile.pairSpacing(leftClass, rightClass)
+			slot: {
+				kind: "gap",
+				boundary: right
+			},
+			spacing: profile.pairSpacing(leftClass, rightClass),
+			absorbsPrecedingEm: 0
 		});
 	}
 	const lastClass = classes[end - 1];
 	const endSpacing = lastClass === void 0 ? null : profile.lineEndSpacing(lastClass);
 	if (endSpacing !== null) result.push({
-		boundary: end,
-		spacing: endSpacing
+		slot: {
+			kind: "gap",
+			boundary: end
+		},
+		spacing: endSpacing.spacing,
+		absorbsPrecedingEm: endSpacing.absorbsPrecedingEm
 	});
 	return result;
 }
-function capacity(values, select) {
-	return values.reduce((total, opportunity) => total + (select(opportunity.spacing)?.amountEm ?? 0), 0);
+/**
+* Break the line's spaces into the indivisible amounts the line adjustment may spend.
+*
+* A line end the profile says absorbs the space before it claims that much of the preceding
+* boundary's capacity, and the two become one unit at the line-end stage — JLReq 3.8.3's third
+* stage, which is free. Whatever the preceding boundary has left over stays an opportunity of its
+* own stage, so the half em of a `、` before a line-end `・` is still spent where 3.8.3 puts it.
+*/
+function adjustmentUnits(values, adjustment) {
+	const select = (spacing) => adjustment === "shrink" ? spacing.shrink : spacing.stretch;
+	const units = [];
+	const straddle = values.find(({ absorbsPrecedingEm }) => absorbsPrecedingEm > 0);
+	let absorbedBoundary;
+	let absorbedEm = 0;
+	let absorbingBoundary;
+	const straddleSlot = straddle?.slot.kind === "gap" ? straddle.slot : void 0;
+	const straddleOwn = straddle === void 0 ? void 0 : select(straddle.spacing);
+	if (straddle !== void 0 && straddleSlot !== void 0 && straddleOwn !== void 0) {
+		const precedingBoundary = straddleSlot.boundary - 1;
+		const preceding = values.find(({ slot }) => slot.kind === "gap" && slot.boundary === precedingBoundary);
+		const availableEm = preceding === void 0 ? 0 : select(preceding.spacing)?.amountEm ?? 0;
+		absorbingBoundary = straddleSlot.boundary;
+		if (availableEm + EPSILON >= straddle.absorbsPrecedingEm) {
+			absorbedBoundary = precedingBoundary;
+			absorbedEm = straddle.absorbsPrecedingEm;
+			units.push({
+				parts: [{
+					slot: {
+						kind: "gap",
+						boundary: precedingBoundary
+					},
+					amountEm: absorbedEm
+				}, {
+					slot: straddleSlot,
+					amountEm: straddleOwn.amountEm
+				}],
+				priority: straddleOwn.priority,
+				amountEm: absorbedEm + straddleOwn.amountEm,
+				granularity: straddleOwn.granularity
+			});
+		}
+	}
+	for (const { slot, spacing } of values) {
+		if (slot.kind === "gap" && slot.boundary === absorbingBoundary) continue;
+		const own = select(spacing);
+		if (own === void 0) continue;
+		const claimedEm = slot.kind === "gap" && slot.boundary === absorbedBoundary ? absorbedEm : 0;
+		const amountEm = own.amountEm - claimedEm;
+		if (amountEm <= EPSILON) continue;
+		units.push({
+			parts: [{
+				slot,
+				amountEm
+			}],
+			priority: own.priority,
+			amountEm,
+			granularity: own.granularity
+		});
+	}
+	return units;
 }
-function resolveSpacings(values, adjustment, amountEm) {
-	const remainingByBoundary = /* @__PURE__ */ new Map();
+/**
+* Spend `amountEm` over the line's units of adjustment, stage by stage.
+*
+* Every stage of JLReq 3.8.3 and 3.8.4 is stated as 文字サイズ比で均等に — the English text of 3.8.3 a puts
+* it as "The same width reduction is applied to all spaces on the target line at the same time."
+* Within a stage the amount is therefore split in proportion to what each space can give, rather
+* than taken out of the earliest space until it runs dry. Across stages the order stays a
+* waterfall: a later stage is reached only once every stage before it is spent out. The composer
+* sets one character size, so a share of the stage's capacity is a share by character size.
+*
+* An all-or-nothing unit larger than what is still needed is skipped rather than partly spent, and
+* never revisited: `remaining` only falls, so a unit that did not fit at its own stage cannot fit
+* at a later one. One forward pass is therefore exact and no search over subsets is needed.
+*/
+function resolveSpacings(values, units, adjustment, amountEm) {
+	const usedBySlot = /* @__PURE__ */ new Map();
 	let remaining = amountEm;
 	let priorityCost = 0;
-	const capacities = values.flatMap((opportunity) => {
-		const selected = adjustment === "shrink" ? opportunity.spacing.shrink : opportunity.spacing.stretch;
-		return selected === void 0 ? [] : [{
-			...opportunity,
-			capacity: selected
-		}];
-	}).sort((left, right) => left.capacity.priority - right.capacity.priority || left.boundary - right.boundary);
-	for (const opportunity of capacities) {
+	let freeEm = 0;
+	const spend = (unit, fraction) => {
+		for (const { slot, amountEm: partEm } of unit.parts) {
+			const key = slotKey(slot);
+			usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + partEm * fraction);
+		}
+		const spentEm = unit.amountEm * fraction;
+		priorityCost += spentEm * unit.priority;
+		if (unit.priority === FREE_SHRINK_PRIORITY) freeEm += spentEm;
+		remaining -= spentEm;
+	};
+	const stages = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		const stage = stages.get(unit.priority);
+		if (stage === void 0) stages.set(unit.priority, [unit]);
+		else stage.push(unit);
+	}
+	for (const priority of [...stages.keys()].sort((left, right) => left - right)) {
 		if (remaining <= EPSILON) break;
-		const used = Math.min(remaining, opportunity.capacity.amountEm);
-		remainingByBoundary.set(opportunity.boundary, used);
-		priorityCost += used * opportunity.capacity.priority;
-		remaining -= used;
+		const stage = stages.get(priority) ?? [];
+		let stageCapacityEm = 0;
+		for (const unit of stage) if (unit.granularity === "continuous") stageCapacityEm += unit.amountEm;
+		else if (unit.amountEm <= remaining + EPSILON) spend(unit, 1);
+		if (stageCapacityEm <= EPSILON || remaining <= EPSILON) continue;
+		const fraction = Math.min(remaining, stageCapacityEm) / stageCapacityEm;
+		for (const unit of stage) if (unit.granularity === "continuous") spend(unit, fraction);
 	}
 	return {
-		spacings: values.map(({ boundary, spacing }) => {
-			const used = remainingByBoundary.get(boundary) ?? 0;
-			return {
-				boundary,
-				kind: spacing.kind,
-				naturalWidthEm: spacing.naturalWidthEm,
-				widthEm: adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used
-			};
+		spacings: splitBySlot(values, (slot, spacing) => {
+			const used = usedBySlot.get(slotKey(slot)) ?? 0;
+			return adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used;
 		}),
-		priorityCost
+		priorityCost,
+		freeEm,
+		unabsorbedEm: Math.max(0, remaining)
+	};
+}
+function splitBySlot(values, widthOf) {
+	const pairSpacings = [];
+	const characterSpacings = [];
+	for (const { slot, spacing } of values) {
+		const resolved = {
+			kind: spacing.kind,
+			naturalWidthEm: spacing.naturalWidthEm,
+			widthEm: widthOf(slot, spacing)
+		};
+		if (slot.kind === "gap") pairSpacings.push({
+			boundary: slot.boundary,
+			...resolved
+		});
+		else characterSpacings.push({
+			index: slot.index,
+			...resolved
+		});
+	}
+	return {
+		pairSpacings,
+		characterSpacings
+	};
+}
+/**
+* The same spaces at the width the profile gives them, for a line no adjustment reaches.
+*/
+function naturalSpacings(values) {
+	return splitBySlot(values, (_slot, spacing) => spacing.naturalWidthEm);
+}
+/**
+* The same, minus the アキ the line end would have taken: a hanging character sits outside the text
+* area and the space that would have followed it goes with it.
+*/
+function hangingSpacings(values, end) {
+	const { pairSpacings, characterSpacings } = naturalSpacings(values);
+	return {
+		pairSpacings: pairSpacings.filter(({ boundary }) => boundary !== end),
+		characterSpacings
 	};
 }
 function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 	const contentStart = skipSourceGaps(atoms, start);
 	const suppressedIndexes = Array.from({ length: contentStart - start }, (_, index) => start + index);
-	const pairValues = opportunities(atoms, classes, contentStart, end, profile);
+	const pairValues = opportunities(atoms, classes, contentStart, end, profile, start === 0 ? "paragraph-start" : "turned-over");
 	const naturalSizeEm = atoms.slice(contentStart, end).reduce((total, atom) => total + atom.boxAdvanceEm, 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
 	const terminal = skipSourceGaps(atoms, end) === atoms.length;
-	const shrinkCapacity = capacity(pairValues, ({ shrink }) => shrink);
-	const freeShrinkCapacity = capacity(pairValues, ({ shrink }) => shrink?.priority === FREE_SHRINK_PRIORITY ? shrink : void 0);
-	const stretchCapacity = capacity(pairValues, ({ stretch }) => stretch);
 	const overflow = naturalSizeEm - lineLengthEm;
 	const underflow = lineLengthEm - naturalSizeEm;
+	const units = adjustmentUnits(pairValues, overflow > 0 ? "shrink" : "stretch");
+	const capacity = units.reduce((total, { amountEm }) => total + amountEm, 0);
+	const freeShrinkCapacity = units.reduce((total, { priority, amountEm }) => total + (priority === FREE_SHRINK_PRIORITY ? amountEm : 0), 0);
 	const lastVisible = previousVisible(atoms, end);
 	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
 	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
-	const trailingSpacing = pairValues.find(({ boundary }) => boundary === end)?.spacing.naturalWidthEm ?? 0;
+	const trailingSpacing = pairValues.find(({ slot }) => slot.kind === "gap" && slot.boundary === end)?.spacing.naturalWidthEm ?? 0;
 	if (terminal && overflow <= EPSILON) return {
 		start,
 		contentStart,
 		end,
 		suppressedIndexes,
-		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		...naturalSpacings(pairValues),
 		inlineSizeEm: naturalSizeEm,
 		break: { kind: "paragraph-end" },
 		hangingIndex: null,
@@ -963,28 +1191,28 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		contentStart,
 		end,
 		suppressedIndexes,
-		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		...naturalSpacings(pairValues),
 		inlineSizeEm: naturalSizeEm,
 		break: { kind: "natural" },
 		hangingIndex: null,
 		deformationRatio: 0,
 		priorityCost: 0
 	};
-	if (overflow > 0 && overflow <= shrinkCapacity + EPSILON) {
-		const resolved = resolveSpacings(pairValues, "shrink", overflow);
-		const chargeableCapacity = shrinkCapacity - freeShrinkCapacity;
-		const chargeableShrink = Math.max(0, overflow - freeShrinkCapacity);
+	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow) : null;
+	if (shrunk !== null && shrunk.unabsorbedEm <= EPSILON) {
+		const chargeableCapacity = capacity - freeShrinkCapacity;
+		const chargeableShrink = Math.max(0, overflow - shrunk.freeEm);
 		return {
 			start,
 			contentStart,
 			end,
 			suppressedIndexes,
-			pairSpacings: resolved.spacings,
+			...shrunk.spacings,
 			inlineSizeEm: lineLengthEm,
 			break: { kind: "shrunk" },
 			hangingIndex: null,
 			deformationRatio: chargeableCapacity <= EPSILON ? 0 : chargeableShrink / chargeableCapacity,
-			priorityCost: resolved.priorityCost
+			priorityCost: shrunk.priorityCost
 		};
 	}
 	if (!terminal && overflow > 0 && lastVisible !== void 0 && lastClass !== void 0 && profile.canHang(lastClass) && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON) return {
@@ -992,34 +1220,32 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		contentStart,
 		end,
 		suppressedIndexes,
-		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings.filter(({ boundary }) => boundary !== end),
+		...hangingSpacings(pairValues, end),
 		inlineSizeEm: naturalSizeEm - lastAdvance - trailingSpacing,
 		break: { kind: "hanging" },
 		hangingIndex: lastVisible,
 		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
 		priorityCost: 0
 	};
-	if (!terminal && underflow > EPSILON && underflow <= stretchCapacity + EPSILON) {
-		const resolved = resolveSpacings(pairValues, "stretch", underflow);
-		return {
-			start,
-			contentStart,
-			end,
-			suppressedIndexes,
-			pairSpacings: resolved.spacings,
-			inlineSizeEm: lineLengthEm,
-			break: { kind: "stretched" },
-			hangingIndex: null,
-			deformationRatio: stretchCapacity === 0 ? 0 : underflow / stretchCapacity,
-			priorityCost: resolved.priorityCost
-		};
-	}
+	const stretched = !terminal && underflow > EPSILON && underflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "stretch", underflow) : null;
+	if (stretched !== null && stretched.unabsorbedEm <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...stretched.spacings,
+		inlineSizeEm: lineLengthEm,
+		break: { kind: "stretched" },
+		hangingIndex: null,
+		deformationRatio: capacity === 0 ? 0 : underflow / capacity,
+		priorityCost: stretched.priorityCost
+	};
 	return {
 		start,
 		contentStart,
 		end,
 		suppressedIndexes,
-		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		...naturalSpacings(pairValues),
 		inlineSizeEm: naturalSizeEm,
 		break: { kind: "forced" },
 		hangingIndex: null,
@@ -1759,7 +1985,9 @@ function positionedLine(atoms, sourceGapIndexes, plan) {
 		}];
 	});
 	const spacings = new Map(plan.pairSpacings.map((spacing) => [spacing.boundary, spacing]));
+	const characterSpacings = new Map(plan.characterSpacings.map((spacing) => [spacing.index, spacing]));
 	let offsetEm = 0;
+	const adjustmentOf = (widthEm, naturalWidthEm) => widthEm < naturalWidthEm ? "shrunk" : widthEm > naturalWidthEm ? "stretched" : "natural";
 	const positionSpacing = (spacing) => {
 		if (spacing.kind === "kern") items.push({
 			kind: "kern",
@@ -1772,7 +2000,7 @@ function positionedLine(atoms, sourceGapIndexes, plan) {
 			offsetEm,
 			widthEm: spacing.widthEm,
 			naturalWidthEm: spacing.naturalWidthEm,
-			adjustment: spacing.widthEm < spacing.naturalWidthEm ? "shrunk" : spacing.widthEm > spacing.naturalWidthEm ? "stretched" : "natural"
+			adjustment: adjustmentOf(spacing.widthEm, spacing.naturalWidthEm)
 		});
 		offsetEm += spacing.widthEm;
 	};
@@ -1781,18 +2009,21 @@ function positionedLine(atoms, sourceGapIndexes, plan) {
 		if (spacing !== void 0) positionSpacing(spacing);
 		const atom = atoms[index];
 		if (atom === void 0) continue;
-		if (sourceGapIndexes.has(index)) {
+		const characterSpacing = characterSpacings.get(index);
+		if (sourceGapIndexes.has(index) || characterSpacing !== void 0) {
+			const naturalWidthEm = characterSpacing?.naturalWidthEm ?? atom.boxAdvanceEm;
+			const widthEm = characterSpacing?.widthEm ?? atom.boxAdvanceEm;
 			items.push({
 				kind: "glue",
 				origin: "source",
 				value: atom.grapheme.value,
 				range: atom.grapheme.range,
 				offsetEm,
-				widthEm: atom.boxAdvanceEm,
-				naturalWidthEm: atom.boxAdvanceEm,
-				adjustment: "natural"
+				widthEm,
+				naturalWidthEm,
+				adjustment: adjustmentOf(widthEm, naturalWidthEm)
 			});
-			offsetEm += atom.boxAdvanceEm;
+			offsetEm += widthEm;
 			continue;
 		}
 		const hanging = plan.hangingIndex === index;

package/dist/plugin.mjs

@@ -1,3 +1,3 @@
 import { c as ManuscriptResult, d as NamespacedId, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CROZLBqt.mjs";
+import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CtovfhET.mjs";
 export { ManuscriptResult, NamespacedId, ParsedManuscript, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushichan044/kg-core",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",