@sushichan044/kg-core 0.9.1 → 0.9.2

package/README.md

@@ -95,9 +95,14 @@ stage, or by hanging a comma or full stop; a short line is answered by opening u
 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
+them, up to a quarter. If those stages cannot fill the line, the remaining width is
+added equally to the admitted pairs in 表6 that are solid at rest, including pairs used by
+the third stage. Intrinsic spaces keep their finite limits: a word space and a mixed
+Japanese-to-Western, numeral, or unit-symbol gap stop at a half em, while punctuation and
+explicit full-em spaces retain their own width. This keeps the unbounded stage from producing
+conspicuous holes around short upright Western words or already-spaced marks.
+Line-head and line-end space, inseparable pairs, and source-authored full-em gaps after
+question or exclamation marks stay fixed. A line with no admitted gap is forced. The choice is made for the
 paragraph rather than line by line,
 minimizing in order the number of forced lines, then stretched, then hanging, then
 shrunk lines that spent visible space. Which space may be reduced, and in which

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-CtovfhET.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-CNBT4TDN.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-CtovfhET.mjs → novel-composer-CNBT4TDN.mjs}

@@ -377,10 +377,6 @@ const REDUCTION_STAGE = {
 * {@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 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.
 */
@@ -396,7 +392,11 @@ const EXPANSION_STAGE = {
 	/**
 	* Stage 3: everywhere else 表6 admits, from solid up to a quarter em.
 	*/
-	solid: 3
+	solid: 3,
+	/**
+	* Stage 4: the unbounded remainder, spread equally across every colored or gray cell of 表6.
+	*/
+	final: 4
 };
 /**
 * 無印 in 表1 with no colour in 表6: the pair is set solid and line adjustment leaves it alone.
@@ -635,6 +635,125 @@ const EXPANDABLE_AFTER = [
 	"cl-30"
 ];
 /**
+* The gray, blue and pink cells of 表6: all pairs that join the fourth and final expansion stage.
+* The finite capacities above cover the blue and pink cells at stages three and two; once those
+* stages are exhausted, JLReq 3.8.4 d adds the remainder equally across every cell named here.
+*
+* A cl-08/cl-08 cell is blue only when the two characters are different kinds of mark (注4). This
+* profile cannot distinguish the two halves of one 2倍ダッシュ from different marks, so it keeps the
+* pair joined, as it already does for the finite third stage.
+*/
+const FINAL_EXPANSION_BASIC_AFTER = /* @__PURE__ */ new Set([
+	"cl-01",
+	"cl-08",
+	"cl-12",
+	"cl-13",
+	"cl-14",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-24",
+	"cl-25",
+	"cl-26",
+	"cl-27",
+	"cl-30"
+]);
+const FINAL_EXPANSION_WIDE_AFTER = /* @__PURE__ */ new Set([
+	...FINAL_EXPANSION_BASIC_AFTER,
+	"cl-09",
+	"cl-10",
+	"cl-11"
+]);
+const FINAL_EXPANSION_AFTER = new Map([
+	...[
+		"cl-02",
+		"cl-03",
+		"cl-04",
+		"cl-05",
+		"cl-06",
+		"cl-07",
+		"cl-14"
+	].map((left) => [left, FINAL_EXPANSION_BASIC_AFTER]),
+	...[
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-13",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-30"
+	].map((left) => [left, FINAL_EXPANSION_WIDE_AFTER]),
+	["cl-08", new Set([...FINAL_EXPANSION_WIDE_AFTER].filter((characterClass) => characterClass !== "cl-08"))],
+	["cl-12", /* @__PURE__ */ new Set([
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-25",
+		"cl-26",
+		"cl-27",
+		"cl-30"
+	])],
+	["cl-24", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-25",
+		"cl-26",
+		"cl-30"
+	])],
+	["cl-25", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-24",
+		"cl-26",
+		"cl-30"
+	])],
+	["cl-26", new Set(japaneseCharacterClasses.filter((characterClass) => characterClass !== "cl-02"))],
+	["cl-27", /* @__PURE__ */ new Set([
+		"cl-01",
+		"cl-08",
+		"cl-09",
+		"cl-10",
+		"cl-11",
+		"cl-12",
+		"cl-13",
+		"cl-14",
+		"cl-15",
+		"cl-16",
+		"cl-19",
+		"cl-26",
+		"cl-30"
+	])]
+]);
+function canExpandAtFinalStage(left, right) {
+	if (left === "cl-14" || left === "cl-26" || left === "cl-27" || right === "cl-14" || right === "cl-26" || right === "cl-27") return false;
+	if (FINAL_EXPANSION_AFTER.get(left)?.has(right) !== true) return false;
+	return pairSpacing(left, right).naturalWidthEm === 0;
+}
+/**
 * The classes JLReq 3.1.2 sets on a half em rather than a full one.
 */
 const HALF_EM_CLASSES = /* @__PURE__ */ new Set([
@@ -922,6 +1041,8 @@ const defaultJapaneseTypesettingProfile = {
 		},
 		absorbsPrecedingEm: .25
 	} : null,
+	finalStretchPriority: EXPANSION_STAGE.final,
+	canExpandAtFinalStage,
 	breakPenalty,
 	/**
 	* Hanging punctuation (ぶら下げ組, JLReq 3.8.2) lets a full stop or comma sit outside the text area
@@ -951,6 +1072,15 @@ function skipSourceGaps(atoms, start) {
 function previousVisible(atoms, end) {
 	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
 }
+/**
+* Whether a shorter line ending somewhere inside `(contentStart, end)` was ever an option — checked
+* as a plain short-circuiting scan rather than building the boundary list first, since this runs
+* once per over-long candidate the optimizer considers.
+*/
+function hasEarlierBoundary(boundaryAllowed, contentStart, end) {
+	for (let boundary = contentStart + 1; boundary < end; boundary += 1) if (boundaryAllowed(boundary - 1, boundary)) return true;
+	return false;
+}
 function opportunities(atoms, classes, start, end, profile, lineHead) {
 	const result = [];
 	const firstClass = classes[start];
@@ -961,6 +1091,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 			boundary: start
 		},
 		spacing: startSpacing,
+		finalStretch: false,
 		absorbsPrecedingEm: 0
 	});
 	for (let index = start; index < end; index += 1) {
@@ -973,6 +1104,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 				index
 			},
 			spacing,
+			finalStretch: false,
 			absorbsPrecedingEm: 0
 		});
 	}
@@ -988,6 +1120,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 				boundary: right
 			},
 			spacing: profile.pairSpacing(leftClass, rightClass),
+			finalStretch: profile.canExpandAtFinalStage(leftClass, rightClass),
 			absorbsPrecedingEm: 0
 		});
 	}
@@ -999,6 +1132,7 @@ function opportunities(atoms, classes, start, end, profile, lineHead) {
 			boundary: end
 		},
 		spacing: endSpacing.spacing,
+		finalStretch: false,
 		absorbsPrecedingEm: endSpacing.absorbsPrecedingEm
 	});
 	return result;
@@ -1072,17 +1206,20 @@ function adjustmentUnits(values, adjustment) {
 * 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.
+* sets one character size, so a share of the stage's capacity is a share by character size. JLReq
+* 3.8.4's final stage has no upper bound: after the finite stages are full, the unresolved
+* remainder is added equally to every pair the profile admits, including the earlier-stage pairs.
 *
 * 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) {
+function resolveSpacings(values, units, adjustment, amountEm, finalStretchPriority) {
 	const usedBySlot = /* @__PURE__ */ new Map();
 	let remaining = amountEm;
 	let priorityCost = 0;
 	let freeEm = 0;
+	let finalStretchPerSlotEm = 0;
 	const spend = (unit, fraction) => {
 		for (const { slot, amountEm: partEm } of unit.parts) {
 			const key = slotKey(slot);
@@ -1109,6 +1246,20 @@ function resolveSpacings(values, units, adjustment, amountEm) {
 		const fraction = Math.min(remaining, stageCapacityEm) / stageCapacityEm;
 		for (const unit of stage) if (unit.granularity === "continuous") spend(unit, fraction);
 	}
+	if (adjustment === "stretch" && remaining > EPSILON) {
+		let finalSlotCount = 0;
+		for (const { finalStretch } of values) if (finalStretch) finalSlotCount += 1;
+		if (finalSlotCount > 0) {
+			finalStretchPerSlotEm = remaining / finalSlotCount;
+			for (const { slot, finalStretch } of values) {
+				if (!finalStretch) continue;
+				const key = slotKey(slot);
+				usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + finalStretchPerSlotEm);
+			}
+			priorityCost += remaining * finalStretchPriority;
+			remaining = 0;
+		}
+	}
 	return {
 		spacings: splitBySlot(values, (slot, spacing) => {
 			const used = usedBySlot.get(slotKey(slot)) ?? 0;
@@ -1116,6 +1267,7 @@ function resolveSpacings(values, units, adjustment, amountEm) {
 		}),
 		priorityCost,
 		freeEm,
+		finalStretchPerSlotEm,
 		unabsorbedEm: Math.max(0, remaining)
 	};
 }
@@ -1159,11 +1311,11 @@ function hangingSpacings(values, end) {
 		characterSpacings
 	};
 }
-function candidate(atoms, classes, start, end, lineLengthEm, profile) {
+function candidate(atoms, classes, boxPrefixEm, 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, 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 naturalSizeEm = (boxPrefixEm[end] ?? 0) - (boxPrefixEm[contentStart] ?? 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
 	const terminal = skipSourceGaps(atoms, end) === atoms.length;
 	const overflow = naturalSizeEm - lineLengthEm;
 	const underflow = lineLengthEm - naturalSizeEm;
@@ -1174,6 +1326,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
 	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
 	const trailingSpacing = pairValues.find(({ slot }) => slot.kind === "gap" && slot.boundary === end)?.spacing.naturalWidthEm ?? 0;
+	const hasFinalStretch = pairValues.some(({ finalStretch }) => finalStretch);
 	if (terminal && overflow <= EPSILON) return {
 		start,
 		contentStart,
@@ -1198,7 +1351,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		deformationRatio: 0,
 		priorityCost: 0
 	};
-	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow) : null;
+	const shrunk = overflow > 0 && overflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "shrink", overflow, profile.finalStretchPriority) : null;
 	if (shrunk !== null && shrunk.unabsorbedEm <= EPSILON) {
 		const chargeableCapacity = capacity - freeShrinkCapacity;
 		const chargeableShrink = Math.max(0, overflow - shrunk.freeEm);
@@ -1227,7 +1380,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
 		priorityCost: 0
 	};
-	const stretched = !terminal && underflow > EPSILON && underflow <= capacity + EPSILON ? resolveSpacings(pairValues, units, "stretch", underflow) : null;
+	const stretched = !terminal && underflow > EPSILON && (underflow <= capacity + EPSILON || hasFinalStretch) ? resolveSpacings(pairValues, units, "stretch", underflow, profile.finalStretchPriority) : null;
 	if (stretched !== null && stretched.unabsorbedEm <= EPSILON) return {
 		start,
 		contentStart,
@@ -1237,7 +1390,7 @@ function candidate(atoms, classes, start, end, lineLengthEm, profile) {
 		inlineSizeEm: lineLengthEm,
 		break: { kind: "stretched" },
 		hangingIndex: null,
-		deformationRatio: capacity === 0 ? 0 : underflow / capacity,
+		deformationRatio: stretched.finalStretchPerSlotEm > 0 ? 1 + stretched.finalStretchPerSlotEm : capacity === 0 ? 0 : underflow / capacity,
 		priorityCost: stretched.priorityCost
 	};
 	return {
@@ -1287,6 +1440,22 @@ function addScore(left, right) {
 		left[6] + right[6]
 	];
 }
+/**
+* The line-end offsets a state's path took, earliest first. Rebuilt on demand by walking `previous`
+* rather than carried on every `State`: every candidate line attempted would otherwise pay for a
+* copy of its whole path, when `isBetter` only ever reads it on the exact-score tie this comparison
+* breaks — for `boundaryAllowed` predicates permissive enough to fully saturate the optimizer's
+* search window, ties are rare enough that this deferred cost is negligible.
+*/
+function breaksOf(state, states) {
+	const result = [];
+	let cursor = state;
+	while (cursor?.line !== null && cursor?.line !== void 0) {
+		result.push(cursor.line.end);
+		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
+	}
+	return result.reverse();
+}
 function compareBreaks(left, right) {
 	const length = Math.min(left.length, right.length);
 	for (let index = 0; index < length; index += 1) {
@@ -1295,17 +1464,19 @@ function compareBreaks(left, right) {
 	}
 	return left.length - right.length;
 }
-function isBetter(candidateState, current) {
+function isBetter(candidateState, current, states) {
 	if (current === void 0) return true;
 	for (let index = 0; index < candidateState.score.length; index += 1) {
 		const difference = (candidateState.score[index] ?? 0) - (current.score[index] ?? 0);
 		if (Math.abs(difference) > EPSILON) return difference < 0;
 	}
-	return compareBreaks(candidateState.breaks, current.breaks) < 0;
+	return compareBreaks(breaksOf(candidateState, states), breaksOf(current, states)) < 0;
 }
 function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 	if (atoms.length === 0) return [];
 	const classes = atoms.map(({ characterClass }) => characterClass);
+	const boxPrefixEm = Array.from({ length: atoms.length + 1 }).fill(0);
+	for (let index = 0; index < atoms.length; index += 1) boxPrefixEm[index + 1] = (boxPrefixEm[index] ?? 0) + (atoms[index]?.boxAdvanceEm ?? 0);
 	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
 		score: [
 			0,
@@ -1318,8 +1489,7 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 		],
 		fitness: 0,
 		previous: null,
-		line: null,
-		breaks: []
+		line: null
 	}]])]]);
 	for (let start = 0; start < atoms.length; start += 1) {
 		const activeStates = states.get(start);
@@ -1327,7 +1497,7 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 		const contentStart = skipSourceGaps(atoms, start);
 		if (contentStart === atoms.length) {
 			const terminalStates = states.get(atoms.length) ?? /* @__PURE__ */ new Map();
-			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness))) terminalStates.set(state.fitness, state);
+			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness), states)) terminalStates.set(state.fitness, state);
 			states.set(atoms.length, terminalStates);
 			continue;
 		}
@@ -1336,8 +1506,8 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 			const left = previousVisible(atoms, end);
 			if (atoms[end - 1]?.sourceGap === true) continue;
 			if (end < atoms.length && right < atoms.length && (left === void 0 || !boundaryAllowed(left, right))) continue;
-			const line = candidate(atoms, classes, start, end, lineLengthEm, profile);
-			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && Array.from({ length: end - contentStart - 1 }, (_, index) => contentStart + index + 1).some((boundary) => boundaryAllowed(boundary - 1, boundary))) {
+			const line = candidate(atoms, classes, boxPrefixEm, start, end, lineLengthEm, profile);
+			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && hasEarlierBoundary(boundaryAllowed, contentStart, end)) {
 				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
 				continue;
 			}
@@ -1349,18 +1519,17 @@ function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
 					index: start,
 					fitness: state.fitness
 				},
-				line,
-				breaks: [...state.breaks, end]
+				line
 			};
 			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
-			if (isBetter(nextState, statesAtEnd.get(nextState.fitness))) {
+			if (isBetter(nextState, statesAtEnd.get(nextState.fitness), states)) {
 				statesAtEnd.set(nextState.fitness, nextState);
 				states.set(end, statesAtEnd);
 			}
 			if (line.inlineSizeEm > lineLengthEm * 2 && line.break.kind === "forced" && end > contentStart + 1) break;
 		}
 	}
-	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best) ? state : best, void 0);
+	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best, states) ? state : best, void 0);
 	if (terminal === void 0) return [];
 	const lines = [];
 	let cursor = terminal;

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-CtovfhET.mjs";
+import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CNBT4TDN.mjs";
 export { ManuscriptResult, NamespacedId, ParsedManuscript, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/package.json

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