@sushichan044/kg-core 0.6.3 → 0.6.5

package/dist/index.mjs

@@ -1004,7 +1004,7 @@ function composeManuscript(parsed, options) {
 }
 //#endregion
 //#region src/composer/composed-annotation-fragment.ts
-const emLength$1 = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const emLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
 const continuation = v.union([
 	v.literal("whole"),
 	v.literal("start"),
@@ -1014,7 +1014,7 @@ const continuation = v.union([
 const PositionedReadingGraphemeSchema = readonlyObject({
 	value: v.string(),
 	offsetEm: v.pipe(v.number(), v.finite()),
-	advanceEm: emLength$1()
+	advanceEm: emLength()
 });
 const common$1 = {
 	annotationRange: ManuscriptRange.schema,
@@ -1039,8 +1039,8 @@ const ComposedAnnotationFragment = { schema: v.variant("kind", [
 		kind: v.literal("ruby"),
 		rubyKind: RubyKind.schema,
 		reading: v.string(),
-		baseOffsetEm: emLength$1(),
-		baseAdvanceEm: emLength$1(),
+		baseOffsetEm: emLength(),
+		baseAdvanceEm: emLength(),
 		readingGraphemes: readonlyArray(PositionedReadingGraphemeSchema),
 		...common$1
 	})
@@ -1139,8 +1139,88 @@ const CompositionStatistics = { schema: readonlyObject({
 	sourceLines: nonNegativeInteger(),
 	pages: nonNegativeInteger()
 }) };
+const InlineSpan = { schema: readonlyObject({
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0))
+}) };
+//#endregion
+//#region src/composer/vertical-text-presentation.ts
+const common = { groupRange: ManuscriptRange.schema };
+const VerticalTextPresentation = { schema: v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("mixed"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("upright"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("sideways"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("tate-chu-yoko"),
+		...common
+	})
+]) };
 //#endregion
-//#region src/composer/inline-measurer.ts
+//#region src/composer/composed-inline-item.ts
+const signedEm = () => v.pipe(v.number(), v.finite());
+const GlyphItemSchema = readonlyObject({
+	kind: v.literal("glyph"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	layoutSpan: InlineSpan.schema,
+	renderSpan: InlineSpan.schema,
+	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
+	presentation: VerticalTextPresentation.schema
+});
+const GeneratedGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("generated"),
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const SourceGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("source"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const KernItemSchema = readonlyObject({
+	kind: v.literal("kern"),
+	offsetEm: signedEm(),
+	widthEm: signedEm()
+});
+const SuppressedItemSchema = readonlyObject({
+	kind: v.literal("suppressed"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	reason: v.literal("question-or-exclamation-gap")
+});
+const ComposedInlineItem = { schema: v.union([
+	GlyphItemSchema,
+	GeneratedGlueItemSchema,
+	SourceGlueItemSchema,
+	KernItemSchema,
+	SuppressedItemSchema
+]) };
+const InlineMeasurement = { schema: readonlyObject({ advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)) }) };
 function graphemeWidth(grapheme) {
 	let width = 1;
 	for (const character of grapheme) {
@@ -1155,9 +1235,17 @@ function graphemeWidth(grapheme) {
 const logicalInlineMeasurer = (request) => {
 	const { text } = request;
 	const width = [...graphemeSegmenter.segment(text)].reduce((total, { segment }) => total + graphemeWidth(segment), 0);
-	if (request.role === "ruby") return width / 2;
-	return request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width;
+	if (request.role === "ruby") return { advanceEm: width / 2 };
+	return { advanceEm: request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width };
 };
+const LineBreakResult = { schema: v.variant("kind", [
+	readonlyObject({ kind: v.literal("natural") }),
+	readonlyObject({ kind: v.literal("shrunk") }),
+	readonlyObject({ kind: v.literal("stretched") }),
+	readonlyObject({ kind: v.literal("hanging") }),
+	readonlyObject({ kind: v.literal("forced") }),
+	readonlyObject({ kind: v.literal("paragraph-end") })
+]) };
 //#endregion
 //#region src/composer/manuscript-geometry.ts
 const STAGE_GAP_CELLS = 2;
@@ -1298,57 +1386,420 @@ function questionOrExclamationSpacings(line) {
 	return [...line.matchAll(MARKS)].map((marks) => analyzeMatch(line, marks)).filter((spacing) => spacing !== void 0);
 }
 //#endregion
-//#region src/composer/vertical-text-presentation.ts
-const common = { groupRange: ManuscriptRange.schema };
-const VerticalTextPresentation = { schema: v.variant("kind", [
-	readonlyObject({
-		kind: v.literal("mixed"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("upright"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("sideways"),
-		...common
+//#region src/composer/internal/japanese-typesetting-profile.ts
+const OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
+const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
+const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
+const DIVIDING_PUNCTUATION = /* @__PURE__ */ new Set("！？‼⁇⁈⁉");
+const MIDDLE_DOTS = /* @__PURE__ */ new Set("・：；");
+const SMALL_KANA = /* @__PURE__ */ new Set("ァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ");
+const ITERATION_MARKS = /* @__PURE__ */ new Set("ヽヾゝゞ々〻");
+const INSEPARABLE = /* @__PURE__ */ new Set("—―…‥─〳〵");
+const PREFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("￥＄£#＃");
+const POSTFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("°′″％‰");
+const UNIT_SYMBOLS = /* @__PURE__ */ new Set("℃℉㎀㎁㎂㎃㎄㎅㎆㎇㎈㎉㎊㎋㎌㎍㎎㎏㎐㎑㎒㎓㎔㎕㎖㎗㎘㎙㎚㎛㎜㎝㎞㎟㎠㎡㎢");
+const GROUPED_NUMERAL = /^[0-9０-９]$/u;
+const HIRAGANA = /^\p{Script=Hiragana}$/u;
+const KATAKANA = /^\p{Script=Katakana}$/u;
+const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
+function classify({ value, presentation }) {
+	if (presentation === "tate-chu-yoko") return "cl-30";
+	if (OPENING.has(value)) return "cl-01";
+	if (CLOSING.has(value)) return "cl-02";
+	if (HYPHENS.has(value)) return "cl-03";
+	if (DIVIDING_PUNCTUATION.has(value)) return "cl-04";
+	if (MIDDLE_DOTS.has(value)) return "cl-05";
+	if (value === "。" || value === "．") return "cl-06";
+	if (value === "、" || value === "，") return "cl-07";
+	if (INSEPARABLE.has(value)) return "cl-08";
+	if (ITERATION_MARKS.has(value)) return "cl-09";
+	if (value === "ー") return "cl-10";
+	if (SMALL_KANA.has(value)) return "cl-11";
+	if (PREFIXED_ABBREVIATIONS.has(value)) return "cl-12";
+	if (POSTFIXED_ABBREVIATIONS.has(value)) return "cl-13";
+	if (value === "　") return "cl-14";
+	if (HIRAGANA.test(value)) return "cl-15";
+	if (KATAKANA.test(value)) return "cl-16";
+	if (GROUPED_NUMERAL.test(value)) return "cl-24";
+	if (UNIT_SYMBOLS.has(value)) return "cl-25";
+	if (value === " ") return "cl-26";
+	if (WESTERN.test(value)) return "cl-27";
+	return "cl-19";
+}
+function pairSpacing(left, right) {
+	if (left === "cl-08" && right === "cl-08") return {
+		kind: "kern",
+		naturalWidthEm: 0
+	};
+	if (left === "cl-01" && right === "cl-01" || left === "cl-02" && right === "cl-02") return {
+		kind: "kern",
+		naturalWidthEm: -.5
+	};
+	if (left === "cl-07" || left === "cl-06") return {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 1,
+			amountEm: .5
+		}
+	};
+	if (left === "cl-02" || right === "cl-01") return {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 2,
+			amountEm: .5
+		}
+	};
+	return {
+		kind: "glue",
+		naturalWidthEm: 0,
+		stretch: {
+			priority: 3,
+			amountEm: .25
+		}
+	};
+}
+function breakPenalty(left, right) {
+	if (left === "cl-01" || left === "cl-12") return null;
+	if (right === "cl-02" || right === "cl-03" || right === "cl-04" || right === "cl-05" || right === "cl-06" || right === "cl-07" || right === "cl-09" || right === "cl-10" || right === "cl-11" || right === "cl-13") return null;
+	if (left === "cl-08" && right === "cl-08") return null;
+	return 0;
+}
+const defaultJapaneseTypesettingProfile = {
+	classify,
+	boxMetrics: (characterClass, measuredAdvanceEm) => ({
+		advanceEm: characterClass === "cl-01" || characterClass === "cl-02" || characterClass === "cl-06" || characterClass === "cl-07" ? Math.min(.5, measuredAdvanceEm) : measuredAdvanceEm,
+		renderOffsetEm: characterClass === "cl-01" ? -.5 : 0
 	}),
-	readonlyObject({
-		kind: v.literal("tate-chu-yoko"),
-		...common
-	})
-]) };
+	pairSpacing,
+	lineStartSpacing: (first) => first === "cl-01" ? {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 2,
+			amountEm: .5
+		}
+	} : null,
+	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: 0,
+			amountEm: .5
+		}
+	} : null,
+	breakPenalty,
+	canHang: (characterClass) => characterClass === "cl-07" || characterClass === "cl-06"
+};
 //#endregion
-//#region src/composer/positioned-grapheme.ts
-const emLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
-const PositionedGrapheme = { schema: readonlyObject({
-	kind: v.literal("grapheme"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	offsetEm: emLength(),
-	advanceEm: emLength(),
-	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
-	presentation: VerticalTextPresentation.schema
-}) };
-const SuppressedGrapheme = { schema: readonlyObject({
-	kind: v.literal("suppressed"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	reason: v.literal("question-or-exclamation-gap")
-}) };
+//#region src/composer/internal/paragraph-layout.ts
+const EPSILON = 1e-9;
+/**
+* Spending capacity at this priority changes nothing the reader can see.
+*/
+const FREE_SHRINK_PRIORITY = 0;
+function skipSourceGaps(atoms, start) {
+	let cursor = start;
+	while (atoms[cursor]?.sourceGap === true) cursor += 1;
+	return cursor;
+}
+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) {
+	const result = [];
+	const firstClass = classes[start];
+	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass);
+	if (startSpacing !== null) result.push({
+		boundary: start,
+		spacing: startSpacing
+	});
+	for (let right = start + 1; right < end; right += 1) {
+		const leftAtom = atoms[right - 1];
+		const rightAtom = atoms[right];
+		const leftClass = classes[right - 1];
+		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)
+		});
+	}
+	const lastClass = classes[end - 1];
+	const endSpacing = lastClass === void 0 ? null : profile.lineEndSpacing(lastClass);
+	if (endSpacing !== null) result.push({
+		boundary: end,
+		spacing: endSpacing
+	});
+	return result;
+}
+function capacity(values, select) {
+	return values.reduce((total, opportunity) => total + (select(opportunity.spacing)?.amountEm ?? 0), 0);
+}
+function resolveSpacings(values, adjustment, amountEm) {
+	const remainingByBoundary = /* @__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) {
+		if (remaining <= EPSILON) break;
+		const used = Math.min(remaining, opportunity.capacity.amountEm);
+		remainingByBoundary.set(opportunity.boundary, used);
+		priorityCost += used * opportunity.capacity.priority;
+		remaining -= used;
+	}
+	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
+			};
+		}),
+		priorityCost
+	};
+}
+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 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 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;
+	if (terminal && overflow <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "paragraph-end" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		priorityCost: 0
+	};
+	if (Math.abs(overflow) <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		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);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			pairSpacings: resolved.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "shrunk" },
+			hangingIndex: null,
+			deformationRatio: chargeableCapacity <= EPSILON ? 0 : chargeableShrink / chargeableCapacity,
+			priorityCost: resolved.priorityCost
+		};
+	}
+	if (!terminal && overflow > 0 && lastVisible !== void 0 && lastClass !== void 0 && profile.canHang(lastClass) && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings.filter(({ boundary }) => boundary !== 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
+		};
+	}
+	return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "forced" },
+		hangingIndex: null,
+		deformationRatio: Math.abs(naturalSizeEm - lineLengthEm) / Math.max(lineLengthEm, EPSILON),
+		priorityCost: 0
+	};
+}
+function scoreFor(line, previousFitness) {
+	const mode = line.break.kind;
+	const fitness = Math.min(3, Math.floor(line.deformationRatio * 4));
+	const transition = Math.abs(previousFitness - fitness) > 1 ? 1 : 0;
+	const modeCounts = {
+		forced: mode === "forced" ? 1 : 0,
+		stretched: mode === "stretched" ? 1 : 0,
+		hanging: mode === "hanging" ? 1 : 0,
+		shrunk: mode === "shrunk" && line.priorityCost > EPSILON ? 1 : 0
+	};
+	return {
+		score: [
+			modeCounts.forced,
+			modeCounts.stretched,
+			modeCounts.hanging,
+			modeCounts.shrunk,
+			line.priorityCost,
+			line.deformationRatio ** 3,
+			transition
+		],
+		fitness
+	};
+}
+function addScore(left, right) {
+	return [
+		left[0] + right[0],
+		left[1] + right[1],
+		left[2] + right[2],
+		left[3] + right[3],
+		left[4] + right[4],
+		left[5] + right[5],
+		left[6] + right[6]
+	];
+}
+function compareBreaks(left, right) {
+	const length = Math.min(left.length, right.length);
+	for (let index = 0; index < length; index += 1) {
+		const difference = (right[index] ?? 0) - (left[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return left.length - right.length;
+}
+function isBetter(candidateState, current) {
+	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;
+}
+function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
+	if (atoms.length === 0) return [];
+	const classes = atoms.map(({ characterClass }) => characterClass);
+	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
+		score: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		fitness: 0,
+		previous: null,
+		line: null,
+		breaks: []
+	}]])]]);
+	for (let start = 0; start < atoms.length; start += 1) {
+		const activeStates = states.get(start);
+		if (activeStates === void 0) continue;
+		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);
+			states.set(atoms.length, terminalStates);
+			continue;
+		}
+		for (const state of activeStates.values()) for (let end = contentStart + 1; end <= atoms.length; end += 1) {
+			const right = skipSourceGaps(atoms, end);
+			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))) {
+				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
+				continue;
+			}
+			const lineScore = scoreFor(line, state.fitness);
+			const nextState = {
+				score: addScore(state.score, lineScore.score),
+				fitness: lineScore.fitness,
+				previous: {
+					index: start,
+					fitness: state.fitness
+				},
+				line,
+				breaks: [...state.breaks, end]
+			};
+			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
+			if (isBetter(nextState, statesAtEnd.get(nextState.fitness))) {
+				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);
+	if (terminal === void 0) return [];
+	const lines = [];
+	let cursor = terminal;
+	while (cursor?.line !== null && cursor?.line !== void 0) {
+		lines.push(cursor.line);
+		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
+	}
+	lines.reverse();
+	const last = lines.at(-1);
+	if (last !== void 0 && last.end < atoms.length) lines[lines.length - 1] = {
+		...last,
+		suppressedIndexes: [...last.suppressedIndexes, ...Array.from({ length: atoms.length - last.end }, (_, index) => last.end + index)]
+	};
+	return lines;
+}
 const NovelLine = {
 	schema: readonlyObject({
 		range: v.nullable(ManuscriptRange.schema),
-		advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
-		graphemes: readonlyArray(PositionedGrapheme.schema),
-		suppressed: readonlyArray(SuppressedGrapheme.schema),
+		inlineSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		items: readonlyArray(ComposedInlineItem.schema),
+		break: LineBreakResult.schema,
 		annotations: readonlyArray(ComposedAnnotationFragment.schema)
 	}),
 	empty: () => ({
 		range: null,
-		advanceEm: 0,
-		graphemes: [],
-		suppressed: [],
+		inlineSizeEm: 0,
+		items: [],
+		break: { kind: "paragraph-end" },
 		annotations: []
 	})
 };
@@ -1380,15 +1831,7 @@ const NovelLayout = { schema: readonlyObject({
 //#endregion
 //#region src/composer/novel-composer.ts
 const COMPOSER_ID = NamespacedId.of("kg/novel");
-const LINE_START_PROHIBITED = /* @__PURE__ */ new Set(`、。，．・：；？！‼⁇⁈⁉ヽヾゝゞ々ーァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ${CLOSING_BRACKETS}】〙〟｠»`);
-const LINE_END_PROHIBITED = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
-const HANGING_PUNCTUATION = /* @__PURE__ */ new Set("、。，．！？");
-const INSEPARABLE_PAIRS = /* @__PURE__ */ new Set([
-	"……",
-	"――",
-	"──",
-	"〳〵"
-]);
+const TYPESETTING_PROFILE = defaultJapaneseTypesettingProfile;
 const ASCII_ALPHANUMERIC = /^[A-Za-z0-9]$/u;
 const ASCII_TWO_DIGITS = /^[0-9]{2}$/u;
 const UPRIGHT_LATIN_ABBREVIATION = /^(?:[A-Z]+|[A-Z][a-z]{1,2})$/u;
@@ -1462,7 +1905,7 @@ function measure(measurer, text, role, settings, presentationKind) {
 		fontPreset: settings.appearance.fontPreset,
 		writingMode: "vertical-rl"
 	};
-	const value = role === "base" ? measurer({
+	const measurement = role === "base" ? measurer({
 		...context,
 		role,
 		presentation: presentationKind ?? "mixed"
@@ -1470,14 +1913,25 @@ function measure(measurer, text, role, settings, presentationKind) {
 		...context,
 		role
 	});
-	return Number.isFinite(value) && value >= 0 ? value : void 0;
+	const parsed = v.safeParse(InlineMeasurement.schema, measurement);
+	if (!parsed.success) return void 0;
+	const { advanceEm } = parsed.output;
+	return advanceEm;
 }
 function measureSourceLine(sourceLine, annotations, settings, measurer) {
 	const mutable = presentedSourceLine(sourceLine).map(({ grapheme, presentation }) => {
-		const advanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
-		return advanceEm === void 0 ? void 0 : {
+		const renderAdvanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
+		if (renderAdvanceEm === void 0) return void 0;
+		const characterClass = TYPESETTING_PROFILE.classify({
+			value: grapheme.value,
+			presentation: presentation.kind
+		});
+		const metrics = TYPESETTING_PROFILE.boxMetrics(characterClass, renderAdvanceEm);
+		return {
 			grapheme,
-			advanceEm,
+			boxAdvanceEm: metrics.advanceEm,
+			renderAdvanceEm,
+			renderOffsetEm: metrics.renderOffsetEm,
 			presentation
 		};
 	});
@@ -1491,11 +1945,11 @@ function measureSourceLine(sourceLine, annotations, settings, measurer) {
 		if (annotation.reading.kind === "group") {
 			const readingAdvance = measure(measurer, annotation.reading.text, "ruby", settings);
 			if (readingAdvance === void 0) return void 0;
-			const baseAdvance = indexes.reduce((total, index) => total + (atoms[index]?.advanceEm ?? 0), 0);
+			const baseAdvance = indexes.reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0);
 			const extra = Math.max(0, readingAdvance - baseAdvance) / indexes.length;
 			for (const index of indexes) {
 				const atom = atoms[index];
-				if (atom !== void 0) atom.advanceEm += extra;
+				if (atom !== void 0) atom.boxAdvanceEm += extra;
 			}
 			continue;
 		}
@@ -1505,7 +1959,7 @@ function measureSourceLine(sourceLine, annotations, settings, measurer) {
 			if (segment === void 0 || atom === void 0) continue;
 			const readingAdvance = measure(measurer, segment, "ruby", settings);
 			if (readingAdvance === void 0) return void 0;
-			atom.advanceEm = Math.max(atom.advanceEm, readingAdvance);
+			atom.boxAdvanceEm = Math.max(atom.boxAdvanceEm, readingAdvance);
 		}
 	}
 	return {
@@ -1520,17 +1974,23 @@ function breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm
 	return annotations.some((annotation) => {
 		if (annotation.kind !== "ruby" || annotation.reading.kind !== "group") return false;
 		if (graphemeIndex <= annotation.range.graphemes.start || graphemeIndex >= annotation.range.graphemes.end) return false;
-		return indicesInside(atoms, annotation).reduce((total, index) => total + (atoms[index]?.advanceEm ?? 0), 0) <= lineLengthEm;
+		return indicesInside(atoms, annotation).reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0) <= lineLengthEm;
 	});
 }
 function samePresentationGroup(left, right) {
 	return left.presentation.groupRange.graphemes.start === right.presentation.groupRange.graphemes.start && left.presentation.groupRange.graphemes.end === right.presentation.groupRange.graphemes.end;
 }
-function legalBoundary(atoms, annotations, boundary, lineLengthEm) {
-	const left = atoms[boundary - 1];
-	const right = atoms[boundary];
+function legalBoundary(atoms, annotations, leftIndex, rightIndex, lineLengthEm, profile) {
+	const left = atoms[leftIndex];
+	const right = atoms[rightIndex];
 	if (left === void 0 || right === void 0) return true;
-	return !samePresentationGroup(left, right) && !LINE_END_PROHIBITED.has(left.grapheme.value) && !LINE_START_PROHIBITED.has(right.grapheme.value) && !INSEPARABLE_PAIRS.has(left.grapheme.value + right.grapheme.value) && !breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm);
+	return !samePresentationGroup(left, right) && profile.breakPenalty(profile.classify({
+		value: left.grapheme.value,
+		presentation: left.presentation.kind
+	}), profile.classify({
+		value: right.grapheme.value,
+		presentation: right.presentation.kind
+	})) !== null && !breakInsideFittableGroupRuby(atoms, annotations, rightIndex, lineLengthEm);
 }
 function continuationFor(annotation, range) {
 	const starts = range.graphemes.start === annotation.range.graphemes.start;
@@ -1602,14 +2062,18 @@ function positionReading(text, baseOffsetEm, baseAdvanceEm, settings, measurer)
 		return positioned;
 	});
 }
-function annotationFragmentRange(graphemes, suppressed, annotation) {
-	return ManuscriptRange.merge([...graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range), ...suppressed.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)]);
+function annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation) {
+	return ManuscriptRange.merge([
+		...graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
+		...suppressed.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
+		...sourceGlues.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)
+	]);
 }
-function annotationFragments(graphemes, suppressed, annotations, settings, measurer, fragmentPlansByAnnotation) {
+function annotationFragments(graphemes, suppressed, sourceGlues, annotations, settings, measurer, fragmentPlansByAnnotation) {
 	const fragments = [];
 	for (const annotation of annotations) {
 		const covered = graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range));
-		const fragmentRange = annotationFragmentRange(graphemes, suppressed, annotation);
+		const fragmentRange = annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation);
 		const first = covered[0];
 		const last = covered.at(-1);
 		if (fragmentRange === null || first === void 0 || last === void 0) continue;
@@ -1636,8 +2100,8 @@ function annotationFragments(graphemes, suppressed, annotations, settings, measu
 			case "ruby": {
 				const fragmentPlan = fragmentPlansByAnnotation.get(annotation);
 				if (fragmentPlan === void 0) break;
-				const baseOffsetEm = first.offsetEm;
-				const baseAdvanceEm = last.offsetEm + last.advanceEm - baseOffsetEm;
+				const baseOffsetEm = first.layoutSpan.offsetEm;
+				const baseAdvanceEm = last.layoutSpan.offsetEm + last.layoutSpan.advanceEm - baseOffsetEm;
 				const reading = readingForFragment(annotation, fragmentRange, fragmentPlan);
 				fragments.push({
 					kind: "ruby",
@@ -1654,88 +2118,103 @@ function annotationFragments(graphemes, suppressed, annotations, settings, measu
 	}
 	return fragments;
 }
-function positionedLine(atoms, dispositions, suppressed) {
+function positionedLine(atoms, sourceGapIndexes, plan) {
+	const items = plan.suppressedIndexes.flatMap((index) => {
+		const atom = atoms[index];
+		return atom === void 0 ? [] : [{
+			kind: "suppressed",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			reason: "question-or-exclamation-gap"
+		}];
+	});
+	const spacings = new Map(plan.pairSpacings.map((spacing) => [spacing.boundary, spacing]));
 	let offsetEm = 0;
-	const graphemes = atoms.map(({ grapheme, advanceEm, presentation }, index) => {
-		const positioned = {
-			kind: "grapheme",
-			value: grapheme.value,
-			range: grapheme.range,
+	const positionSpacing = (spacing) => {
+		if (spacing.kind === "kern") items.push({
+			kind: "kern",
 			offsetEm,
-			advanceEm,
-			disposition: dispositions.has(index) ? "hanging" : "placed",
-			presentation
-		};
-		offsetEm += advanceEm;
-		return positioned;
-	});
-	return {
-		range: ManuscriptRange.merge([...graphemes.map(({ range }) => range), ...suppressed.map(({ range }) => range)]),
-		advanceEm: offsetEm,
-		graphemes,
-		suppressed,
-		annotations: []
+			widthEm: spacing.widthEm
+		});
+		else items.push({
+			kind: "glue",
+			origin: "generated",
+			offsetEm,
+			widthEm: spacing.widthEm,
+			naturalWidthEm: spacing.naturalWidthEm,
+			adjustment: spacing.widthEm < spacing.naturalWidthEm ? "shrunk" : spacing.widthEm > spacing.naturalWidthEm ? "stretched" : "natural"
+		});
+		offsetEm += spacing.widthEm;
 	};
-}
-function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
-	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
-	const lines = [];
-	let cursor = 0;
-	while (cursor < sourceLine.atoms.length) {
-		const suppressed = [];
-		if (lines.length > 0 && sourceLine.suppressedIndexes.has(cursor)) {
-			const atom = sourceLine.atoms[cursor];
-			if (atom !== void 0) suppressed.push({
-				kind: "suppressed",
+	for (let index = plan.contentStart; index < plan.end; index += 1) {
+		const spacing = spacings.get(index);
+		if (spacing !== void 0) positionSpacing(spacing);
+		const atom = atoms[index];
+		if (atom === void 0) continue;
+		if (sourceGapIndexes.has(index)) {
+			items.push({
+				kind: "glue",
+				origin: "source",
 				value: atom.grapheme.value,
 				range: atom.grapheme.range,
-				reason: "question-or-exclamation-gap"
+				offsetEm,
+				widthEm: atom.boxAdvanceEm,
+				naturalWidthEm: atom.boxAdvanceEm,
+				adjustment: "natural"
 			});
-			cursor += 1;
-		}
-		if (cursor >= sourceLine.atoms.length) {
-			const previous = lines.at(-1);
-			if (previous !== void 0 && suppressed.length > 0) lines[lines.length - 1] = {
-				...previous,
-				range: ManuscriptRange.merge([...previous.range === null ? [] : [previous.range], ...suppressed.map(({ range }) => range)]),
-				suppressed: [...previous.suppressed, ...suppressed]
-			};
-			break;
-		}
-		const start = cursor;
-		let advance = 0;
-		while (cursor < sourceLine.atoms.length) {
-			const atom = sourceLine.atoms[cursor];
-			if (atom === void 0) break;
-			const previous = sourceLine.atoms[cursor - 1];
-			const beginsPresentationGroup = previous === void 0 || !samePresentationGroup(previous, atom);
-			if (cursor > start && beginsPresentationGroup) {
-				let groupAdvance = 0;
-				for (let index = cursor; index < sourceLine.atoms.length; index += 1) {
-					const member = sourceLine.atoms[index];
-					if (member === void 0 || !samePresentationGroup(atom, member)) break;
-					groupAdvance += member.advanceEm;
-				}
-				if (advance + groupAdvance > settings.flow.lineLengthEm) break;
-			}
-			if (cursor > start && advance + atom.advanceEm > settings.flow.lineLengthEm && (previous === void 0 || !samePresentationGroup(previous, atom))) break;
-			advance += atom.advanceEm;
-			cursor += 1;
+			offsetEm += atom.boxAdvanceEm;
+			continue;
 		}
-		let end = Math.max(start + 1, cursor);
-		const hanging = /* @__PURE__ */ new Set();
-		const next = sourceLine.atoms[end];
-		if (next !== void 0 && HANGING_PUNCTUATION.has(next.grapheme.value)) {
-			hanging.add(end - start);
-			end += 1;
-		} else while (end > start + 1 && !legalBoundary(sourceLine.atoms, annotations, end, settings.flow.lineLengthEm)) end -= 1;
-		const atoms = sourceLine.atoms.slice(start, end);
-		lines.push(positionedLine(atoms, hanging, suppressed));
-		cursor = end;
+		const hanging = plan.hangingIndex === index;
+		const layoutAdvanceEm = hanging ? 0 : atom.boxAdvanceEm;
+		items.push({
+			kind: "glyph",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			layoutSpan: {
+				offsetEm,
+				advanceEm: layoutAdvanceEm
+			},
+			renderSpan: {
+				offsetEm: offsetEm + atom.renderOffsetEm,
+				advanceEm: atom.renderAdvanceEm
+			},
+			disposition: hanging ? "hanging" : "placed",
+			presentation: atom.presentation
+		});
+		offsetEm += layoutAdvanceEm;
 	}
+	const trailingSpacing = spacings.get(plan.end);
+	if (trailingSpacing !== void 0) positionSpacing(trailingSpacing);
+	const ranges = items.flatMap((item) => item.kind === "glyph" || item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
+	return {
+		range: ManuscriptRange.merge(ranges),
+		inlineSizeEm: Math.max(0, plan.inlineSizeEm),
+		items,
+		break: plan.break,
+		annotations: []
+	};
+}
+function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
+	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
+	const profile = TYPESETTING_PROFILE;
+	const lines = layoutParagraph(sourceLine.atoms.map(({ grapheme, boxAdvanceEm, presentation }, index) => {
+		const current = sourceLine.atoms[index];
+		const next = sourceLine.atoms[index + 1];
+		return {
+			value: grapheme.value,
+			boxAdvanceEm,
+			sourceGap: sourceLine.suppressedIndexes.has(index),
+			characterClass: profile.classify({
+				value: grapheme.value,
+				presentation: presentation.kind
+			}),
+			pairSpacingAfter: current === void 0 || next === void 0 || !samePresentationGroup(current, next) && !breakInsideFittableGroupRuby(sourceLine.atoms, annotations, index + 1, settings.flow.lineLengthEm)
+		};
+	}), settings.flow.lineLengthEm, profile, (leftIndex, rightIndex) => legalBoundary(sourceLine.atoms, annotations, leftIndex, rightIndex, settings.flow.lineLengthEm, profile)).map((plan) => positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, plan));
 	const fragmentPlansByAnnotation = new Map(annotations.map((annotation) => {
 		const ranges = lines.flatMap((line) => {
-			const range = annotationFragmentRange(line.graphemes, line.suppressed, annotation);
+			const range = annotationFragmentRange(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotation);
 			return range === null ? [] : [range];
 		});
 		return [annotation, {
@@ -1745,10 +2224,10 @@ function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvance
 	}));
 	return lines.map((line) => ({
 		range: line.range,
-		advanceEm: line.advanceEm,
-		graphemes: line.graphemes,
-		suppressed: line.suppressed,
-		annotations: annotationFragments(line.graphemes, line.suppressed, annotations, settings, measurer, fragmentPlansByAnnotation)
+		inlineSizeEm: line.inlineSizeEm,
+		items: line.items,
+		break: line.break,
+		annotations: annotationFragments(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotations, settings, measurer, fragmentPlansByAnnotation)
 	}));
 }
 function blankLines(count) {
@@ -1789,7 +2268,7 @@ function createCompose(measurer) {
 		const measured = sourceLines.map((line) => measureSourceLine(line, manuscript.annotations, settings, measurer));
 		if (measured.some((line) => line === void 0)) return ManuscriptResult.fail({ reason: "inline measurer returned a negative or non-finite value" });
 		const baseAdvances = /* @__PURE__ */ new Map();
-		for (const line of measured) for (const atom of line?.atoms ?? []) baseAdvances.set(atom.grapheme.range.graphemes.start, atom.advanceEm);
+		for (const line of measured) for (const atom of line?.atoms ?? []) baseAdvances.set(atom.grapheme.range.graphemes.start, atom.boxAdvanceEm);
 		const manuscriptLines = measured.flatMap((line) => line === void 0 ? [] : wrapSourceLine(line, manuscript.annotations, settings, measurer, baseAdvances));
 		const pages = buildPages([
 			...blankLines(settings.offsets.document.leading),
@@ -2561,4 +3040,4 @@ function createDefaultProofreadingRules() {
 	];
 }
 //#endregion
-export { BoldAnnotation, ComposeError, ComposedAnnotationFragment, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, InvalidRuleOptions, ItalicAnnotation, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, NovelCompositionSettings, NovelFlowSettings, NovelLayout, NovelLine, NovelPage, NovelStage, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, PositionedGrapheme, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, RubyKind, RubyReading, SourcePosition, SourceRange, SuppressedGrapheme, TextRange, ValidationIssue, VerticalTextPresentation, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createNovelComposer, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, logicalInlineMeasurer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, novelComposer, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };
+export { BoldAnnotation, ComposeError, ComposedAnnotationFragment, ComposedInlineItem, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, InlineMeasurement, InlineSpan, InvalidRuleOptions, ItalicAnnotation, LineBreakResult, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, NovelCompositionSettings, NovelFlowSettings, NovelLayout, NovelLine, NovelPage, NovelStage, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, RubyKind, RubyReading, SourcePosition, SourceRange, TextRange, ValidationIssue, VerticalTextPresentation, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createNovelComposer, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, logicalInlineMeasurer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, novelComposer, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };