@sushichan044/kg-core 0.9.5 → 0.10.1

package/dist/novel-composer-D_orH6ET.mjs

@@ -0,0 +1,3393 @@
+import { _ as readonlyArray, a as CLOSING_BRACKETS, c as graphemeSegmenter, g as nonNegativeInteger, h as TextRange, i as TATE_CHU_YOKO_MARKS, m as ManuscriptRange, o as OPENING_BRACKETS, p as NamespacedId, r as DIVIDING_PUNCTUATION, s as characterClass, t as questionOrExclamationSpacings, u as ManuscriptResult, v as readonlyObject } from "./question-or-exclamation-spacing-Cp3eOGlA.mjs";
+import * as v from "valibot";
+import { eastAsianWidth } from "get-east-asian-width";
+const BoldAnnotation = { schema: readonlyObject({
+	kind: v.literal("bold"),
+	range: ManuscriptRange.schema
+}) };
+const EmphasisAnnotation = { schema: readonlyObject({
+	kind: v.literal("emphasis"),
+	range: ManuscriptRange.schema,
+	mark: v.string()
+}) };
+const ItalicAnnotation = { schema: readonlyObject({
+	kind: v.literal("italic"),
+	range: ManuscriptRange.schema
+}) };
+//#endregion
+//#region src/parser/annotation/ruby-annotation.ts
+const GroupRubyKindSchema = v.literal("group");
+const MonoRubyKindSchema = v.literal("mono");
+const JukugoRubyKindSchema = v.literal("jukugo");
+const RubyKindSchema = v.union([
+	GroupRubyKindSchema,
+	MonoRubyKindSchema,
+	JukugoRubyKindSchema
+]);
+const RubyReadingSchema = v.variant("kind", [
+	readonlyObject({
+		kind: GroupRubyKindSchema,
+		text: v.pipe(v.string(), v.nonEmpty())
+	}),
+	readonlyObject({
+		kind: MonoRubyKindSchema,
+		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
+	}),
+	readonlyObject({
+		kind: JukugoRubyKindSchema,
+		segments: v.pipe(v.array(v.pipe(v.string(), v.nonEmpty())), v.nonEmpty(), v.readonly())
+	})
+]);
+const RubyAnnotationSchema = readonlyObject({
+	kind: v.literal("ruby"),
+	range: ManuscriptRange.schema,
+	reading: RubyReadingSchema
+});
+const RubyKind = { schema: RubyKindSchema };
+const RubyAnnotation = { schema: RubyAnnotationSchema };
+const ManuscriptAnnotation = {
+	schema: v.variant("kind", [
+		RubyAnnotation.schema,
+		BoldAnnotation.schema,
+		ItalicAnnotation.schema,
+		EmphasisAnnotation.schema
+	]),
+	/**
+	* Stable order for rendering: outermost span first, then by variant name.
+	*/
+	compare: (left, right) => left.range.source.start - right.range.source.start || left.range.source.end - right.range.source.end || left.kind.localeCompare(right.kind)
+};
+const ParsedGrapheme = { schema: readonlyObject({
+	value: v.string(),
+	range: ManuscriptRange.schema
+}) };
+//#endregion
+//#region src/parser/parsed-manuscript.ts
+const ParsedManuscriptSchema = readonlyObject({
+	source: v.string(),
+	displayText: v.string(),
+	graphemes: readonlyArray(ParsedGrapheme.schema),
+	annotations: readonlyArray(ManuscriptAnnotation.schema)
+});
+function rangeFits(range, manuscript) {
+	return range.source.end <= manuscript.source.length && range.display.end <= manuscript.displayText.length && range.graphemes.end <= manuscript.graphemes.length;
+}
+function hasValidRubyAssociations(manuscript) {
+	const ruby = manuscript.annotations.filter((annotation) => annotation.kind === "ruby");
+	return ruby.every((annotation, index) => {
+		const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
+		if (baseLength <= 0) return false;
+		if (annotation.reading.kind !== "group" && annotation.reading.segments.length !== baseLength) return false;
+		return ruby.slice(index + 1).every((other) => !ManuscriptRange.overlaps(annotation.range, other.range));
+	});
+}
+function isConsistent(manuscript, source) {
+	const joined = manuscript.graphemes.map(({ value }) => value).join("");
+	const sequential = manuscript.graphemes.every(({ range }, index) => range.graphemes.start === index && range.graphemes.end === index + 1 && rangeFits(range, manuscript));
+	return manuscript.source === source && manuscript.displayText === joined && sequential && manuscript.annotations.every(({ range }) => rangeFits(range, manuscript)) && hasValidRubyAssociations(manuscript);
+}
+const CONTRACT_MESSAGE = "parser output must contain consistent source, display, grapheme, and annotation ranges and valid ruby associations";
+const ParsedManuscript = {
+	schema: ParsedManuscriptSchema,
+	/**
+	* The parser contract as a schema: shape, plus the cross-field invariants that make the three
+	* coordinate systems line up. Annotations come out in a stable order regardless of parser.
+	*/
+	contractFor: (source) => v.pipe(ParsedManuscriptSchema, v.check((manuscript) => isConsistent(manuscript, source), CONTRACT_MESSAGE), v.transform((manuscript) => ({
+		...manuscript,
+		annotations: [...manuscript.annotations].sort(ManuscriptAnnotation.compare)
+	})))
+};
+//#endregion
+//#region src/appearance/font-preset-id.ts
+const FontPresetIdSchema = v.picklist(["mincho", "gothic"]);
+const FontPresetId = {
+	schema: FontPresetIdSchema,
+	is: (value) => v.is(FontPresetIdSchema, value)
+};
+//#endregion
+//#region src/appearance/font-size-pt.ts
+const RANGE = {
+	min: 6,
+	max: 24,
+	step: .5
+};
+const FontSizePtSchema = v.pipe(v.number(), v.finite(), v.minValue(RANGE.min), v.maxValue(RANGE.max), v.multipleOf(RANGE.step));
+const FontSizePt = {
+	schema: FontSizePtSchema,
+	range: RANGE,
+	is: (value) => v.is(FontSizePtSchema, value)
+};
+//#endregion
+//#region src/appearance/paper-size-id.ts
+const PaperSizeIdSchema = v.picklist([
+	"a4",
+	"a5",
+	"a6",
+	"jis-b5",
+	"jis-b6",
+	"shinsho"
+]);
+const PaperSizeId = {
+	schema: PaperSizeIdSchema,
+	is: (value) => v.is(PaperSizeIdSchema, value)
+};
+const ManuscriptAppearanceSettings = {
+	schema: readonlyObject({
+		paperSize: PaperSizeId.schema,
+		fontSizePt: FontSizePt.schema,
+		fontPreset: FontPresetId.schema
+	}),
+	defaults: {
+		paperSize: "a5",
+		fontSizePt: 9,
+		fontPreset: "mincho"
+	}
+};
+const LineOffset = {
+	schema: readonlyObject({
+		leading: nonNegativeInteger(),
+		trailing: nonNegativeInteger()
+	}),
+	total: (offset) => offset.leading + offset.trailing
+};
+//#endregion
+//#region src/composer/manuscript-offsets.ts
+const MAX_DOCUMENT_OFFSET = 1e4;
+const ManuscriptOffsets = {
+	schema: readonlyObject({
+		document: readonlyObject({
+			leading: nonNegativeInteger(MAX_DOCUMENT_OFFSET),
+			trailing: nonNegativeInteger(MAX_DOCUMENT_OFFSET)
+		}),
+		page: LineOffset.schema,
+		stage: LineOffset.schema
+	}),
+	defaults: {
+		document: {
+			leading: 0,
+			trailing: 0
+		},
+		page: {
+			leading: 0,
+			trailing: 0
+		},
+		stage: {
+			leading: 0,
+			trailing: 0
+		}
+	},
+	/**
+	* Stage offsets must leave at least one usable line in the stage.
+	*/
+	maxStageTotal: (flow) => Math.max(0, flow.linesPerStage - 1),
+	/**
+	* Page offsets must leave at least one usable line on the page, after stage offsets apply.
+	*/
+	maxPageTotal: (flow, stage) => Math.max(0, (flow.linesPerStage - LineOffset.total(stage)) * flow.stagesPerPage - 1)
+};
+//#endregion
+//#region src/composer/novel-flow-settings.ts
+const RANGES = {
+	lineLengthEm: {
+		min: 10,
+		max: 60
+	},
+	linesPerStage: {
+		min: 10,
+		max: 60
+	},
+	stagesPerPage: {
+		min: 1,
+		max: 3
+	}
+};
+const boundedCount = (bounds) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(bounds.min), v.maxValue(bounds.max));
+const NovelFlowSettings = {
+	schema: readonlyObject({
+		lineLengthEm: boundedCount(RANGES.lineLengthEm),
+		linesPerStage: boundedCount(RANGES.linesPerStage),
+		stagesPerPage: boundedCount(RANGES.stagesPerPage)
+	}),
+	ranges: RANGES,
+	defaults: {
+		lineLengthEm: 27,
+		linesPerStage: 23,
+		stagesPerPage: 2
+	}
+};
+//#endregion
+//#region src/composer/composition-settings.ts
+const NovelCompositionSettingsSchema = v.pipe(readonlyObject({
+	flow: NovelFlowSettings.schema,
+	offsets: ManuscriptOffsets.schema,
+	appearance: ManuscriptAppearanceSettings.schema
+}), v.check(({ flow, offsets }) => LineOffset.total(offsets.stage) <= ManuscriptOffsets.maxStageTotal(flow) && LineOffset.total(offsets.page) <= ManuscriptOffsets.maxPageTotal(flow, offsets.stage), "page or stage offsets leave no usable novel lines"));
+const NovelCompositionSettings = {
+	schema: NovelCompositionSettingsSchema,
+	defaults: {
+		flow: NovelFlowSettings.defaults,
+		offsets: ManuscriptOffsets.defaults,
+		appearance: ManuscriptAppearanceSettings.defaults
+	},
+	is: (value) => v.is(NovelCompositionSettingsSchema, value)
+};
+//#endregion
+//#region src/composer/internal/annotation-style.ts
+const defaultAnnotationStyle = {
+	sizeEm: .5,
+	areaStartEm: -.5,
+	areaEndEm: 0
+};
+//#endregion
+//#region src/composer/internal/book-style.ts
+const shrink = {
+	"line-end": {
+		stage: 0,
+		costPerEm: 0
+	},
+	"word-space": {
+		stage: 1,
+		costPerEm: 1
+	},
+	"middle-dot": {
+		stage: 2,
+		costPerEm: 2
+	},
+	punctuation: {
+		stage: 3,
+		costPerEm: 3
+	},
+	"mixed-text": {
+		stage: 4,
+		costPerEm: 4
+	},
+	solid: {
+		stage: 4,
+		costPerEm: 4
+	}
+};
+const stretch = {
+	"word-space": {
+		stage: 1,
+		costPerEm: 1
+	},
+	"mixed-text": {
+		stage: 2,
+		costPerEm: 2
+	},
+	solid: {
+		stage: 3,
+		costPerEm: 3
+	},
+	"line-end": {
+		stage: 3,
+		costPerEm: 3
+	},
+	"middle-dot": {
+		stage: 3,
+		costPerEm: 3
+	},
+	punctuation: {
+		stage: 3,
+		costPerEm: 3
+	}
+};
+const defaultBookStyle = {
+	adjustment: (direction, category) => (direction === "shrink" ? shrink : stretch)[category],
+	lineStartSpacing: (first, head) => first === "cl-01" && head === "paragraph-start" ? {
+		kind: "glue",
+		naturalWidthEm: .5
+	} : null,
+	finalStretchCostPerEm: 4,
+	annotation: defaultAnnotationStyle
+};
+//#endregion
+//#region src/composer/internal/annotation-clearance.ts
+const EPSILON$7 = 1e-9;
+function overlaps(left, right) {
+	return left.inlineSpan.offsetEm < right.inlineSpan.offsetEm + right.inlineSpan.advanceEm - EPSILON$7 && right.inlineSpan.offsetEm < left.inlineSpan.offsetEm + left.inlineSpan.advanceEm - EPSILON$7 && left.blockOffsetEm < right.blockOffsetEm + right.blockSizeEm - EPSILON$7 && right.blockOffsetEm < left.blockOffsetEm + left.blockSizeEm - EPSILON$7;
+}
+const AnnotationClearance = { resolve: (areas) => {
+	for (const area of areas) if (area.some((placement) => placement.side !== "before" || placement.blockOffsetEm < defaultBookStyle.annotation.areaStartEm - EPSILON$7 || placement.blockOffsetEm + placement.blockSizeEm > defaultBookStyle.annotation.areaEndEm + EPSILON$7)) return {
+		kind: "refused",
+		reason: "annotation exceeds the fixed half-em right-side area"
+	};
+	for (const [index, area] of areas.entries()) if (areas.slice(index + 1).some((other) => area.some((left) => other.some((right) => overlaps(left, right))))) return {
+		kind: "refused",
+		reason: "annotation readings or emphasis marks overlap in the fixed right-side area"
+	};
+	return { kind: "clear" };
+} };
+//#endregion
+//#region src/composer/internal/binding-sequence.ts
+const BindingSequence = { contains: (left, right) => left === right || (left === "〳" || left === "〴") && right === "〵" };
+//#endregion
+//#region src/composer/internal/boundary-rule.ts
+function breakConstraint(left, right, profile, context) {
+	if (context.runInterior) return {
+		kind: "prohibited",
+		reason: "run-interior"
+	};
+	if (context.bindingSequence) return {
+		kind: "prohibited",
+		reason: "binding-sequence"
+	};
+	const penalty = profile.breakPenalty(left, right);
+	if (penalty === null) return {
+		kind: "prohibited",
+		reason: left === "cl-01" || left === "cl-12" ? "line-end" : "line-head"
+	};
+	if (context.rubyInterior) return {
+		kind: "prohibited",
+		reason: "ruby-interior"
+	};
+	return {
+		kind: "allowed",
+		penalty
+	};
+}
+const BoundaryRule = { resolve: (left, right, profile, context) => {
+	const spacingAllowed = !context.runInterior && !context.rubySpacingInterior && !context.sourceGap;
+	return {
+		break: breakConstraint(left, right, profile, context),
+		spacing: !spacingAllowed ? null : context.bindingSequence ? {
+			kind: "kern",
+			naturalWidthEm: 0
+		} : profile.pairSpacing(left, right),
+		finalStretch: spacingAllowed && !context.bindingSequence && profile.canExpandAtFinalStage(left, right)
+	};
+} };
+//#endregion
+//#region src/composer/internal/composition-run.ts
+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;
+const TATE_CHU_YOKO_MARK = new RegExp(`^[${characterClass(TATE_CHU_YOKO_MARKS)}]$`, "u");
+const FULLWIDTH_ALPHANUMERIC = /^[Ａ-Ｚａ-ｚ０-９]$/u;
+function stretchEnd(graphemes, start, pattern) {
+	let end = start + 1;
+	while (pattern.test(graphemes[end]?.value ?? "")) end += 1;
+	return end;
+}
+function presentationOf(text) {
+	if (ASCII_ALPHANUMERIC.test(text[0] ?? "")) {
+		if (ASCII_TWO_DIGITS.test(text)) return "tate-chu-yoko";
+		return text.length === 1 || UPRIGHT_LATIN_ABBREVIATION.test(text) ? "upright" : "sideways";
+	}
+	return FULLWIDTH_ALPHANUMERIC.test(text) ? "upright" : "mixed";
+}
+function recognize(graphemes) {
+	const runs = [];
+	const push = (members, presentation) => {
+		const range = ManuscriptRange.merge(members.map((member) => member.range));
+		if (range !== null) runs.push({
+			range,
+			presentation,
+			members
+		});
+	};
+	let cursor = 0;
+	while (cursor < graphemes.length) {
+		const first = graphemes[cursor];
+		if (first === void 0) break;
+		if (TATE_CHU_YOKO_MARK.test(first.value)) {
+			const end = stretchEnd(graphemes, cursor, TATE_CHU_YOKO_MARK);
+			const members = graphemes.slice(cursor, end);
+			if (members.length === 2 || members.length === 3) push(members, "tate-chu-yoko");
+			else for (const member of members) push([member], "mixed");
+			cursor = end;
+			continue;
+		}
+		const end = ASCII_ALPHANUMERIC.test(first.value) ? stretchEnd(graphemes, cursor, ASCII_ALPHANUMERIC) : cursor + 1;
+		const members = graphemes.slice(cursor, end);
+		push(members, presentationOf(members.map(({ value }) => value).join("")));
+		cursor = end;
+	}
+	return runs;
+}
+const CompositionRun = { recognize };
+//#endregion
+//#region src/composer/internal/emphasis-placement.ts
+const { sizeEm } = defaultBookStyle.annotation;
+const EmphasisPlacement = {
+	accepts: (characterClass) => characterClass !== void 0 && ![
+		"cl-01",
+		"cl-02",
+		"cl-06",
+		"cl-07"
+	].some((value) => value === characterClass),
+	of: (base) => ({
+		side: "before",
+		inlineSpan: {
+			offsetEm: base.offsetEm + (base.advanceEm - sizeEm) / 2,
+			advanceEm: sizeEm
+		},
+		blockOffsetEm: -sizeEm,
+		blockSizeEm: sizeEm
+	})
+};
+//#endregion
+//#region src/composer/measurement-text-range.ts
+const MeasurementTextRangeSchema = v.pipe(TextRange.schema, v.brand("MeasurementTextRange"));
+const MeasurementTextRange = {
+	schema: MeasurementTextRangeSchema,
+	of: (range) => v.parse(MeasurementTextRangeSchema, range)
+};
+//#endregion
+//#region src/composer/internal/group-ruby-allocation.ts
+function nearestBoundary(prefix, target) {
+	let low = 0;
+	let high = prefix.length - 1;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		if ((prefix[middle] ?? 0) < target) low = middle + 1;
+		else high = middle;
+	}
+	return low > 0 && target - (prefix[low - 1] ?? 0) < (prefix[low] ?? 0) - target ? low - 1 : low;
+}
+const GroupRubyAllocation = {
+	prepare: (association, pieces, advancesEm) => {
+		const start = association.indexes[0];
+		const last = association.indexes.at(-1);
+		if (start === void 0 || last === void 0) return void 0;
+		const basePrefixEm = [0];
+		for (const index of association.indexes) basePrefixEm.push((basePrefixEm.at(-1) ?? 0) + (advancesEm[index] ?? 0));
+		const readingPrefixGraphemes = [0];
+		for (const piece of pieces) readingPrefixGraphemes.push((readingPrefixGraphemes.at(-1) ?? 0) + [...graphemeSegmenter.segment(piece.value)].length);
+		return {
+			association,
+			start,
+			end: last + 1,
+			pieces,
+			basePrefixEm,
+			readingPrefixGraphemes
+		};
+	},
+	assign: (group, start, end, cursor, lineLengthEm) => {
+		const fragmentStart = Math.max(start, group.start);
+		const fragmentEnd = Math.min(end, group.end);
+		const readingStart = start <= group.start ? 0 : cursor;
+		const totalBase = group.basePrefixEm.at(-1) ?? 0;
+		const consumedBase = group.basePrefixEm[fragmentEnd - group.start] ?? totalBase;
+		const baseFraction = totalBase > 0 ? consumedBase / totalBase : (fragmentEnd - group.start) / (group.end - group.start);
+		const target = Math.round(baseFraction * (group.readingPrefixGraphemes.at(-1) ?? 0));
+		let readingEnd = nearestBoundary(group.readingPrefixGraphemes, target);
+		if (fragmentEnd === group.end) readingEnd = group.pieces.length;
+		else {
+			const remainingFragments = Math.max(1, Math.ceil((totalBase - consumedBase) / lineLengthEm));
+			const reserve = group.pieces.length - readingStart >= remainingFragments + 1;
+			const minimum = reserve ? readingStart + 1 : readingStart;
+			const maximum = reserve ? group.pieces.length - remainingFragments : group.pieces.length;
+			readingEnd = Math.max(minimum, Math.min(maximum, readingEnd));
+		}
+		const selected = group.pieces.slice(readingStart, readingEnd);
+		const textStart = selected[0]?.textRange.start ?? 0;
+		const layoutStart = selected[0]?.layoutSpan.offsetEm ?? 0;
+		const pieces = selected.map((piece) => ({
+			value: piece.value,
+			textRange: MeasurementTextRange.of({
+				start: piece.textRange.start - textStart,
+				end: piece.textRange.end - textStart
+			}),
+			layoutSpan: {
+				advanceEm: piece.layoutSpan.advanceEm,
+				offsetEm: piece.layoutSpan.offsetEm - layoutStart
+			},
+			renderSpan: {
+				advanceEm: piece.renderSpan.advanceEm,
+				offsetEm: piece.renderSpan.offsetEm - layoutStart
+			}
+		}));
+		return {
+			segment: {
+				association: group.association,
+				start: fragmentStart,
+				end: fragmentEnd,
+				pieces
+			},
+			nextCursor: fragmentEnd === group.end ? 0 : readingEnd
+		};
+	}
+};
+//#endregion
+//#region src/composer/internal/adjustment-unit.ts
+const AdjustmentUnit = {
+	capacity: (unit) => unit.parts.reduce((total, part) => total + part.capacityEm, 0),
+	of: (direction, capacity, parts) => ({
+		direction,
+		kind: capacity.granularity,
+		stage: capacity.stage,
+		costPerEm: capacity.costPerEm,
+		parts
+	})
+};
+//#endregion
+//#region src/composer/internal/spacing-slot.ts
+const SpacingSlot = { key: (slot) => slot.kind === "gap" ? slot.boundary * 2 : slot.index * 2 + 1 };
+//#endregion
+//#region src/composer/internal/spacing-allocation.ts
+const EPSILON$6 = 1e-9;
+function resolveSpacings(values, units, adjustment, amountEm, finalExpansion) {
+	const usedBySlot = /* @__PURE__ */ new Map();
+	let remaining = amountEm;
+	let deformationCost = 0;
+	let freeEm = 0;
+	let finalStretchPerSlotEm = 0;
+	const spend = (unit, fraction) => {
+		for (const { slot, capacityEm: partEm } of unit.parts) {
+			const key = SpacingSlot.key(slot);
+			usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + partEm * fraction);
+		}
+		const spentEm = AdjustmentUnit.capacity(unit) * fraction;
+		deformationCost += spentEm * unit.costPerEm;
+		if (unit.costPerEm === 0) freeEm += spentEm;
+		remaining -= spentEm;
+	};
+	const stages = /* @__PURE__ */ new Map();
+	for (const unit of units) {
+		if (unit.direction !== adjustment) continue;
+		const stage = stages.get(unit.stage);
+		if (stage === void 0) stages.set(unit.stage, [unit]);
+		else stage.push(unit);
+	}
+	for (const stageIndex of [...stages.keys()].sort((left, right) => left - right)) {
+		if (remaining <= EPSILON$6) break;
+		const stage = stages.get(stageIndex) ?? [];
+		let stageCapacityEm = 0;
+		for (const unit of stage) if (unit.kind === "continuous") stageCapacityEm += AdjustmentUnit.capacity(unit);
+		else if (AdjustmentUnit.capacity(unit) <= remaining + EPSILON$6) spend(unit, 1);
+		if (stageCapacityEm <= EPSILON$6 || remaining <= EPSILON$6) continue;
+		const fraction = Math.min(remaining, stageCapacityEm) / stageCapacityEm;
+		for (const unit of stage) if (unit.kind === "continuous") spend(unit, fraction);
+	}
+	if (adjustment === "stretch" && remaining > EPSILON$6) {
+		const finalSlotCount = finalExpansion.slots.length;
+		if (finalSlotCount > 0) {
+			finalStretchPerSlotEm = remaining / finalSlotCount;
+			for (const slot of finalExpansion.slots) {
+				const key = SpacingSlot.key(slot);
+				usedBySlot.set(key, (usedBySlot.get(key) ?? 0) + finalStretchPerSlotEm);
+			}
+			deformationCost += remaining * finalExpansion.costPerEm;
+			remaining = 0;
+		}
+	}
+	return {
+		spacings: splitBySlot(values, (slot, spacing) => {
+			const used = usedBySlot.get(SpacingSlot.key(slot)) ?? 0;
+			return adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used;
+		}),
+		deformationCost,
+		freeEm,
+		finalStretchPerSlotEm,
+		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 their resolved natural width, 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
+	};
+}
+//#endregion
+//#region src/composer/internal/candidate-line.ts
+const EPSILON$5 = 1e-9;
+const CandidateLine = { resolve: (context, lineLengthEm) => {
+	const { start, contentStart, end, suppressedIndexes, boxesSizeEm, terminal, lastVisible, lastAdvance, canHang, pairValues, unitsFor, finalExpansion } = context;
+	const naturalSizeEm = boxesSizeEm + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
+	const overflow = naturalSizeEm - lineLengthEm;
+	const underflow = lineLengthEm - naturalSizeEm;
+	const units = unitsFor(overflow > 0 ? "shrink" : "stretch");
+	const capacity = units.reduce((total, unit) => total + AdjustmentUnit.capacity(unit), 0);
+	const freeShrinkCapacity = units.reduce((total, unit) => total + (unit.costPerEm === 0 ? AdjustmentUnit.capacity(unit) : 0), 0);
+	const trailingSpacing = pairValues.find(({ slot }) => slot.kind === "gap" && slot.boundary === end)?.spacing.naturalWidthEm ?? 0;
+	const hasFinalStretch = finalExpansion.slots.length > 0;
+	if (terminal && overflow <= EPSILON$5) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...naturalSpacings(pairValues),
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "paragraph-end" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		deformationCost: 0
+	};
+	if (Math.abs(overflow) <= EPSILON$5) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...naturalSpacings(pairValues),
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "natural" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		deformationCost: 0
+	};
+	const shrunk = overflow > 0 && overflow <= capacity + EPSILON$5 ? resolveSpacings(pairValues, units, "shrink", overflow, finalExpansion) : null;
+	if (shrunk !== null && shrunk.unabsorbedEm <= EPSILON$5) {
+		const chargeableCapacity = capacity - freeShrinkCapacity;
+		const chargeableShrink = Math.max(0, overflow - shrunk.freeEm);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			...shrunk.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "shrunk" },
+			hangingIndex: null,
+			deformationRatio: chargeableCapacity <= EPSILON$5 ? 0 : chargeableShrink / chargeableCapacity,
+			deformationCost: shrunk.deformationCost
+		};
+	}
+	if (!terminal && overflow > 0 && lastVisible !== void 0 && canHang && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON$5) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...hangingSpacings(pairValues, end),
+		inlineSizeEm: naturalSizeEm - lastAdvance - trailingSpacing,
+		break: { kind: "hanging" },
+		hangingIndex: lastVisible,
+		deformationRatio: overflow / Math.max(lastAdvance, EPSILON$5),
+		deformationCost: 0
+	};
+	const stretched = !terminal && underflow > EPSILON$5 && (underflow <= capacity + EPSILON$5 || hasFinalStretch) ? resolveSpacings(pairValues, units, "stretch", underflow, finalExpansion) : null;
+	if (stretched !== null && stretched.unabsorbedEm <= EPSILON$5) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...stretched.spacings,
+		inlineSizeEm: lineLengthEm,
+		break: { kind: "stretched" },
+		hangingIndex: null,
+		deformationRatio: stretched.finalStretchPerSlotEm > 0 ? 1 + stretched.finalStretchPerSlotEm : capacity === 0 ? 0 : underflow / capacity,
+		deformationCost: stretched.deformationCost
+	};
+	return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		...naturalSpacings(pairValues),
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "forced" },
+		hangingIndex: null,
+		deformationRatio: Math.abs(naturalSizeEm - lineLengthEm) / Math.max(lineLengthEm, EPSILON$5),
+		deformationCost: 0
+	};
+} };
+//#endregion
+//#region src/composer/internal/japanese-adjustment-units.ts
+const EPSILON$4 = 1e-9;
+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$4 >= straddle.absorbsPrecedingEm) {
+			absorbedBoundary = precedingBoundary;
+			absorbedEm = straddle.absorbsPrecedingEm;
+			units.push(AdjustmentUnit.of(adjustment, straddleOwn, [{
+				slot: {
+					kind: "gap",
+					boundary: precedingBoundary
+				},
+				capacityEm: absorbedEm
+			}, {
+				slot: straddleSlot,
+				capacityEm: straddleOwn.amountEm
+			}]));
+		}
+	}
+	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$4) continue;
+		units.push(AdjustmentUnit.of(adjustment, own, [{
+			slot,
+			capacityEm: amountEm
+		}]));
+	}
+	return units;
+}
+//#endregion
+//#region src/composer/internal/japanese-paragraph.ts
+const JapaneseParagraph = {
+	prefixAdvances: (advancesEm) => {
+		const prefix = [0];
+		for (const advance of advancesEm) prefix.push((prefix.at(-1) ?? 0) + advance);
+		return prefix;
+	},
+	of: (characters, boundaries, profile, lineLengthEm) => {
+		const prefixEm = JapaneseParagraph.prefixAdvances(characters.map(({ boxAdvanceEm }) => boxAdvanceEm));
+		const nextVisible = Array.from({ length: characters.length + 1 }).fill(characters.length);
+		const previousVisible = Array.from({ length: characters.length + 1 });
+		for (let index = characters.length - 1; index >= 0; index -= 1) nextVisible[index] = characters[index]?.sourceGap === true ? nextVisible[index + 1] ?? characters.length : index;
+		for (let end = 1; end <= characters.length; end += 1) previousVisible[end] = characters[end - 1]?.sourceGap === true ? previousVisible[end - 1] : end - 1;
+		const edges = characters.map(({ characterClass, effectiveClass }) => ({
+			paragraphHead: profile.lineStartSpacing(effectiveClass, "paragraph-start"),
+			turnedHead: profile.lineStartSpacing(effectiveClass, "turned-over"),
+			end: profile.lineEndSpacing(effectiveClass),
+			sourceMid: profile.spacingCharacter(characterClass, "mid-line"),
+			sourceEdge: profile.spacingCharacter(characterClass, "line-edge"),
+			canHang: profile.canHang(effectiveClass)
+		}));
+		return {
+			elements: characters,
+			resolveCandidate: (start, end, metrics) => {
+				const contentStart = nextVisible[start] ?? characters.length;
+				const values = [];
+				const head = edges[contentStart];
+				const headSpacing = (start === 0 ? head?.paragraphHead : head?.turnedHead) ?? null;
+				if (headSpacing !== null) values.push({
+					slot: {
+						kind: "gap",
+						boundary: contentStart
+					},
+					spacing: headSpacing,
+					absorbsPrecedingEm: 0
+				});
+				for (let index = contentStart; index < end; index += 1) {
+					if (characters[index]?.sourceGap === true) continue;
+					const edge = edges[index];
+					const spacing = (index === contentStart || index === end - 1 ? edge?.sourceEdge : edge?.sourceMid) ?? null;
+					if (spacing !== null) values.push({
+						slot: {
+							kind: "character",
+							index
+						},
+						spacing,
+						absorbsPrecedingEm: 0
+					});
+				}
+				const finalSlots = [];
+				for (let boundary = contentStart + 1; boundary < end; boundary += 1) {
+					const rule = boundaries[boundary];
+					if (rule?.spacing === void 0 || rule.spacing === null) continue;
+					const slot = {
+						kind: "gap",
+						boundary
+					};
+					values.push({
+						slot,
+						spacing: rule.spacing,
+						absorbsPrecedingEm: 0
+					});
+					if (rule.finalStretch) finalSlots.push(slot);
+				}
+				const tail = edges[end - 1]?.end ?? null;
+				if (tail !== null) values.push({
+					slot: {
+						kind: "gap",
+						boundary: end
+					},
+					spacing: tail.spacing,
+					absorbsPrecedingEm: tail.absorbsPrecedingEm
+				});
+				const lastVisible = previousVisible[end];
+				for (const extra of metrics?.extraSpacings ?? []) {
+					const index = values.findIndex(({ slot }) => slot.kind === "gap" && slot.boundary === extra.boundary);
+					const existing = values[index];
+					if (existing === void 0) values.push({
+						slot: {
+							kind: "gap",
+							boundary: extra.boundary
+						},
+						spacing: {
+							kind: "glue",
+							naturalWidthEm: extra.widthEm
+						},
+						absorbsPrecedingEm: 0
+					});
+					else values[index] = {
+						...existing,
+						spacing: {
+							...existing.spacing,
+							naturalWidthEm: existing.spacing.naturalWidthEm + extra.widthEm
+						}
+					};
+				}
+				const extraBoxesEm = metrics?.boxAdjustments.reduce((sum, box) => sum + box.advanceEm - (characters[box.index]?.boxAdvanceEm ?? 0), 0) ?? 0;
+				const line = CandidateLine.resolve({
+					start,
+					contentStart,
+					end,
+					suppressedIndexes: Array.from({ length: contentStart - start }, (_, index) => start + index),
+					boxesSizeEm: (prefixEm[end] ?? 0) - (prefixEm[contentStart] ?? 0) + extraBoxesEm,
+					terminal: nextVisible[end] === characters.length,
+					lastVisible,
+					lastAdvance: lastVisible === void 0 ? 0 : metrics?.boxAdjustments.find((box) => box.index === lastVisible)?.advanceEm ?? characters[lastVisible]?.boxAdvanceEm ?? 0,
+					canHang: lastVisible !== void 0 && edges[lastVisible]?.canHang === true,
+					pairValues: values,
+					unitsFor: (direction) => adjustmentUnits(values, direction),
+					finalExpansion: {
+						slots: finalSlots,
+						costPerEm: profile.finalStretchCostPerEm
+					}
+				}, lineLengthEm);
+				return metrics === void 0 ? line : {
+					...line,
+					boxAdjustments: metrics.boxAdjustments
+				};
+			}
+		};
+	}
+};
+//#endregion
+//#region src/composer/internal/japanese-typesetting-rules.ts
+/**
+* The JLReq character classes (文字クラス) these rules distinguish. The bare `cl-NN` identifiers are
+* kept rather than descriptive names so the spacing and penalty tables below can be read side by
+* side with the tables in the specification.
+*
+* JLReq defines thirty classes. Math (cl-17, cl-18) and warichu brackets (cl-28, cl-29) are absent
+* because a novel is not set with them. The base-group classes are absent for a different reason: a
+* novel does carry ruby (cl-22, cl-23), but ruby is an annotation the composer positions
+* separately, and `JapaneseCharacter` cannot describe a base group at all — nor a reference mark
+* (cl-20) or a subscripted base (cl-21). A base character is therefore classified here as whatever
+* it is on its own, which for the kanji that usually carries ruby means cl-19.
+*
+* @see https://www.w3.org/TR/jlreq/#character_classes
+*/
+const japaneseCharacterClasses = [
+	"cl-01",
+	"cl-02",
+	"cl-03",
+	"cl-04",
+	"cl-05",
+	"cl-06",
+	"cl-07",
+	"cl-08",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-12",
+	"cl-13",
+	"cl-14",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-24",
+	"cl-25",
+	"cl-26",
+	"cl-27",
+	"cl-30"
+];
+const boundaryClasses = [
+	...japaneseCharacterClasses,
+	"cl-22",
+	"cl-23"
+];
+const OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
+const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
+const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
+const DIVIDING_MARKS = new Set(DIVIDING_PUNCTUATION);
+const COMBINED_DIVIDING_MARKS = new Set(TATE_CHU_YOKO_MARKS);
+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;
+/**
+* Order matters: a character inside a tate-chu-yoko group is cl-30 (3.2.5) and an upright Latin
+* letter or Arabic numeral is cl-19 (3.2.4), whatever either would be on its own; anything left
+* unmatched is cl-19 too, the class JLReq reserves for kanji and the like. A tate-chu-yoko `！？`
+* stays cl-04, the class JLReq gives `⁉`, so it still may not open a line.
+*
+* The quarter em 3.2.6 sets between Japanese and a Western character or numeral applies only to a
+* character rotated 90 degrees in vertical writing mode or mixed into horizontal writing mode —
+* 3.2.6 states that scope explicitly. A character set upright keeps its own rule, 3.2.4, which
+* reads it as a full-width monospace glyph classed with kanji and set solid against its neighbours,
+* the same as a tate-chu-yoko run's 3.2.5.
+*/
+function classify({ value, presentation }) {
+	if (presentation === "tate-chu-yoko") return COMBINED_DIVIDING_MARKS.has(value) ? "cl-04" : "cl-30";
+	if (presentation === "upright") return "cl-19";
+	if (OPENING.has(value)) return "cl-01";
+	if (CLOSING.has(value)) return "cl-02";
+	if (HYPHENS.has(value)) return "cl-03";
+	if (DIVIDING_MARKS.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";
+}
+/**
+* 無印 in 表1 with no colour in 表6: the pair is set solid and line adjustment leaves it alone.
+*/
+const SOLID = {
+	kind: "glue",
+	naturalWidthEm: 0
+};
+/**
+* `1/4` in 表6: set solid, but line adjustment may open it up to a quarter em.
+*/
+const SOLID_EXPANDABLE = {
+	kind: "glue",
+	naturalWidthEm: 0,
+	stretch: {
+		category: "solid",
+		amountEm: .25,
+		granularity: "continuous"
+	}
+};
+/**
+* `1/2` in 表1 with `1/2-0` in 表3: a half em that line adjustment may take down to solid.
+*/
+const HALF = {
+	kind: "glue",
+	naturalWidthEm: .5,
+	shrink: {
+		category: "punctuation",
+		amountEm: .5,
+		granularity: "continuous"
+	}
+};
+/**
+* `1/2` in both tables: the half em exists but is not a reduction opportunity.
+*/
+const FIXED_HALF = {
+	kind: "glue",
+	naturalWidthEm: .5
+};
+/**
+* `1/4` in 表1 with `1/4-0` in 表3: a quarter em that may go down to solid.
+*/
+const QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .25,
+	shrink: {
+		category: "middle-dot",
+		amountEm: .25,
+		granularity: "continuous"
+	}
+};
+/**
+* `1/4` in both tables: the quarter em exists but is not a reduction opportunity.
+*/
+const FIXED_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .25
+};
+/**
+* `1/4-1/8` in 表3 with `1/4-1/2` in 表6: the Japanese-to-western quarter em, reducible to an eighth
+* and expandable to a half. 3.2.6 sets this only against a Western character rotated 90 degrees or
+* mixed into horizontal text (cl-27) and a numeral or unit symbol (cl-24, cl-25); an upright
+* Western character classifies as cl-19 instead and never reaches this constant.
+*/
+const MIXED_TEXT_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .25,
+	shrink: {
+		category: "mixed-text",
+		amountEm: .125,
+		granularity: "continuous"
+	},
+	stretch: {
+		category: "mixed-text",
+		amountEm: .25,
+		granularity: "continuous"
+	}
+};
+/**
+* The same quarter em where 表6 leaves it out of the expansion: between a unit symbol and the
+* quantity on either side of it.
+*/
+const UNIT_SYMBOL_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .25,
+	shrink: {
+		category: "mixed-text",
+		amountEm: .125,
+		granularity: "continuous"
+	}
+};
+/**
+* 表1 注3 with 表3 注1: two middle dots meet, and their quarters go solid together.
+*/
+const TWO_QUARTERS = {
+	kind: "glue",
+	naturalWidthEm: .5,
+	shrink: {
+		category: "middle-dot",
+		amountEm: .5,
+		granularity: "continuous"
+	}
+};
+/**
+* 表1 注5 with 表3 注2: a full stop's fixed half em plus the following middle dot's quarter.
+*/
+const FIXED_HALF_AND_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .75,
+	shrink: {
+		category: "middle-dot",
+		amountEm: .25,
+		granularity: "continuous"
+	}
+};
+/**
+* 表1 注5 with 表3 注3: a comma's half em plus the following middle dot's quarter.
+*
+* 表3 spends the quarter at stage 4 and the half at stage 5, which one capacity cannot say. Both are
+* reducible to solid, so the total is right and only the order collapses — and `、・` is rare enough
+* that the order never shows.
+*/
+const HALF_AND_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .75,
+	shrink: {
+		category: "punctuation",
+		amountEm: .75,
+		granularity: "continuous"
+	}
+};
+/**
+* 欧文間隔（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: {
+		category: "word-space",
+		amountEm: 1 / 3 - 1 / 4,
+		granularity: "continuous"
+	},
+	stretch: {
+		category: "word-space",
+		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 rotated 90
+* degrees or mixed into horizontal text (3.2.6) — an upright western character classifies as cl-19
+* and is covered by the general kanji rows and columns instead. Dividing punctuation is on the list
+* in that direction only, because the space before a `？` or `！` is solid (3.1.6).
+*/
+const JAPANESE_BEFORE_WESTERN = [
+	"cl-04",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30",
+	"cl-22",
+	"cl-23"
+];
+const JAPANESE_AFTER_WESTERN = [
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30",
+	"cl-22",
+	"cl-23"
+];
+const NUMERAL_UNIT_OR_WESTERN = [
+	"cl-24",
+	"cl-25",
+	"cl-27"
+];
+const PUNCTUATION_TAKING_SPACE_AFTER = [
+	"cl-02",
+	"cl-06",
+	"cl-07"
+];
+/**
+* 表6 の色付きの小間: the classes a solid pair may be opened up between at stage 3. Neither list holds a
+* bracket, a middle dot, a full stop, a comma, a hyphen, an ideographic space or a word space —
+* JLReq opens none of those — and only the left-hand list holds a numeral, unit symbol or western
+* character, since the space on their Japanese side belongs to stage 2 instead.
+*/
+const EXPANDABLE_BEFORE = [
+	"cl-08",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-12",
+	"cl-13",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-24",
+	"cl-25",
+	"cl-27",
+	"cl-30",
+	"cl-22",
+	"cl-23"
+];
+const EXPANDABLE_AFTER = [
+	"cl-08",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-12",
+	"cl-13",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30",
+	"cl-22",
+	"cl-23"
+];
+/**
+* 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 for different kinds of mark (注4). BoundaryRule excludes binding
+* sequences using the original character values.
+*/
+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", FINAL_EXPANSION_WIDE_AFTER],
+	["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;
+	const leftClass = left === "cl-22" || left === "cl-23" ? "cl-19" : left;
+	const rightClass = right === "cl-22" || right === "cl-23" ? "cl-19" : right;
+	if (FINAL_EXPANSION_AFTER.get(leftClass)?.has(rightClass) !== 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([
+	"cl-01",
+	"cl-02",
+	"cl-05",
+	"cl-06",
+	"cl-07"
+]);
+const PAIR_SPACING_TABLE = new Map([
+	{
+		left: "any",
+		right: "any",
+		spacing: SOLID
+	},
+	{
+		left: EXPANDABLE_BEFORE,
+		right: EXPANDABLE_AFTER,
+		spacing: SOLID_EXPANDABLE
+	},
+	{
+		left: [
+			"cl-08",
+			"cl-12",
+			"cl-13"
+		],
+		right: NUMERAL_UNIT_OR_WESTERN,
+		spacing: SOLID_EXPANDABLE
+	},
+	{
+		left: ["cl-08"],
+		right: ["cl-24", "cl-25"],
+		spacing: SOLID
+	},
+	{
+		left: ["cl-12"],
+		right: ["cl-24"],
+		spacing: SOLID
+	},
+	{
+		left: ["cl-24"],
+		right: ["cl-13"],
+		spacing: SOLID
+	},
+	{
+		left: [
+			"cl-09",
+			"cl-10",
+			"cl-11"
+		],
+		right: ["cl-08"],
+		spacing: SOLID
+	},
+	{
+		left: "any",
+		right: ["cl-01"],
+		spacing: HALF
+	},
+	{
+		left: "any",
+		right: ["cl-05"],
+		spacing: QUARTER
+	},
+	{
+		left: "any",
+		right: PUNCTUATION_TAKING_SPACE_AFTER,
+		spacing: SOLID
+	},
+	{
+		left: JAPANESE_BEFORE_WESTERN,
+		right: NUMERAL_UNIT_OR_WESTERN,
+		spacing: MIXED_TEXT_QUARTER
+	},
+	{
+		left: NUMERAL_UNIT_OR_WESTERN,
+		right: JAPANESE_AFTER_WESTERN,
+		spacing: MIXED_TEXT_QUARTER
+	},
+	{
+		left: ["cl-25"],
+		right: ["cl-24"],
+		spacing: UNIT_SYMBOL_QUARTER
+	},
+	{
+		left: ["cl-27"],
+		right: ["cl-25"],
+		spacing: UNIT_SYMBOL_QUARTER
+	},
+	{
+		left: ["cl-24"],
+		right: ["cl-25"],
+		spacing: FIXED_QUARTER
+	},
+	{
+		left: ["cl-02", "cl-07"],
+		right: "any",
+		spacing: HALF
+	},
+	{
+		left: ["cl-06"],
+		right: "any",
+		spacing: FIXED_HALF
+	},
+	{
+		left: ["cl-02"],
+		right: ["cl-05"],
+		spacing: QUARTER
+	},
+	{
+		left: ["cl-06"],
+		right: ["cl-05"],
+		spacing: FIXED_HALF_AND_QUARTER
+	},
+	{
+		left: ["cl-07"],
+		right: ["cl-05"],
+		spacing: HALF_AND_QUARTER
+	},
+	{
+		left: PUNCTUATION_TAKING_SPACE_AFTER,
+		right: PUNCTUATION_TAKING_SPACE_AFTER,
+		spacing: SOLID
+	},
+	{
+		left: ["cl-02"],
+		right: ["cl-14"],
+		spacing: SOLID
+	},
+	{
+		left: ["cl-05"],
+		right: "any",
+		spacing: QUARTER
+	},
+	{
+		left: ["cl-05"],
+		right: ["cl-05"],
+		spacing: TWO_QUARTERS
+	},
+	{
+		left: ["cl-01"],
+		right: "any",
+		spacing: SOLID
+	},
+	{
+		left: ["cl-01"],
+		right: ["cl-05"],
+		spacing: QUARTER
+	},
+	{
+		left: ["cl-14"],
+		right: "any",
+		spacing: SOLID
+	},
+	{
+		left: ["cl-14"],
+		right: ["cl-05"],
+		spacing: QUARTER
+	},
+	{
+		left: "any",
+		right: ["cl-26"],
+		spacing: SOLID
+	},
+	{
+		left: PUNCTUATION_TAKING_SPACE_AFTER,
+		right: ["cl-26"],
+		spacing: FIXED_HALF
+	},
+	{
+		left: ["cl-05"],
+		right: ["cl-26"],
+		spacing: FIXED_QUARTER
+	},
+	{
+		left: ["cl-26"],
+		right: "any",
+		spacing: SOLID
+	},
+	{
+		left: ["cl-26"],
+		right: ["cl-01"],
+		spacing: FIXED_HALF
+	},
+	{
+		left: ["cl-26"],
+		right: ["cl-05"],
+		spacing: FIXED_QUARTER
+	},
+	{
+		left: ["cl-08"],
+		right: ["cl-08"],
+		spacing: SOLID_EXPANDABLE
+	}
+].flatMap(({ left, right, spacing }) => (left === "any" ? boundaryClasses : left).flatMap((leftClass) => (right === "any" ? boundaryClasses : right).map((rightClass) => [`${leftClass}/${rightClass}`, spacing]))));
+function pairSpacing(left, right) {
+	return PAIR_SPACING_TABLE.get(`${left}/${right}`) ?? SOLID;
+}
+/**
+* `null` removes the break opportunity outright rather than pricing it, because the three rules
+* below are prohibitions and not preferences.
+*
+* Line-end prohibition (行末禁則, JLReq 3.1.8): an opening bracket or a prefixed abbreviation may not
+* be the last character on a line, since it belongs to what follows it.
+*
+* Line-start prohibition (行頭禁則, JLReq 3.1.7): closing brackets, hyphens, dividing punctuation,
+* middle dots, full stops, commas, iteration marks, the prolonged sound mark, small kana and
+* postfixed abbreviations may not open a line.
+*
+* Binding sequences (JLReq C.2 note 5) depend on the actual characters and are resolved separately
+* by BoundaryRule.
+*/
+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;
+	return 0;
+}
+const defaultJapaneseTypesettingRules = {
+	classify,
+	/**
+	* Opening and closing brackets, full stops, commas and middle dots are set on a half em (JLReq
+	* 3.1.2); the space the pair table puts around them is what brings each back to a full em.
+	*
+	* A fullwidth glyph keeps drawing its ink where the font put it, so halving the advance alone
+	* would leave the ink outside the box. The offset pulls it back: an opening bracket draws in the
+	* 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 {
+			advanceEm,
+			renderOffsetEm: characterClass === "cl-01" ? -inkOverhangEm : characterClass === "cl-05" ? -inkOverhangEm / 2 : 0
+		};
+	},
+	pairSpacing,
+	spacingCharacter: (characterClass, position) => characterClass !== "cl-26" ? null : position === "mid-line" ? WORD_SPACE : EDGE_WORD_SPACE,
+	/**
+	* 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). The book style selects their order and visual cost.
+	*
+	* 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" ? {
+		spacing: {
+			kind: "glue",
+			naturalWidthEm: .5,
+			shrink: {
+				category: "line-end",
+				amountEm: .5,
+				granularity: "all-or-nothing"
+			}
+		},
+		absorbsPrecedingEm: 0
+	} : last === "cl-05" ? {
+		spacing: {
+			kind: "glue",
+			naturalWidthEm: .25,
+			shrink: {
+				category: "line-end",
+				amountEm: .25,
+				granularity: "all-or-nothing"
+			}
+		},
+		absorbsPrecedingEm: .25
+	} : null,
+	canExpandAtFinalStage,
+	breakPenalty,
+	/**
+	* Hanging punctuation (ぶら下げ組, JLReq 3.8.2) lets a full stop or comma sit outside the text area
+	* instead of forcing the line to be respaced. JLReq admits no other class for it.
+	*/
+	canHang: (characterClass) => characterClass === "cl-07" || characterClass === "cl-06"
+};
+const defaultJapaneseTypesettingProfile = { of: (rules, style) => {
+	const resolved = /* @__PURE__ */ new WeakMap();
+	const spacing = (rule) => {
+		const cached = resolved.get(rule);
+		if (cached !== void 0) return cached;
+		const result = {
+			kind: rule.kind,
+			naturalWidthEm: rule.naturalWidthEm,
+			...rule.shrink === void 0 ? {} : { shrink: {
+				amountEm: rule.shrink.amountEm,
+				granularity: rule.shrink.granularity,
+				...style.adjustment("shrink", rule.shrink.category)
+			} },
+			...rule.stretch === void 0 ? {} : { stretch: {
+				amountEm: rule.stretch.amountEm,
+				granularity: rule.stretch.granularity,
+				...style.adjustment("stretch", rule.stretch.category)
+			} }
+		};
+		resolved.set(rule, result);
+		return result;
+	};
+	return {
+		classify: rules.classify,
+		boxMetrics: rules.boxMetrics,
+		pairSpacing: (left, right) => spacing(rules.pairSpacing(left, right)),
+		spacingCharacter: (characterClass, position) => {
+			const rule = rules.spacingCharacter(characterClass, position);
+			return rule === null ? null : {
+				...spacing(rule),
+				kind: "glue"
+			};
+		},
+		lineStartSpacing: style.lineStartSpacing,
+		lineEndSpacing: (last) => {
+			const rule = rules.lineEndSpacing(last);
+			return rule === null ? null : {
+				spacing: spacing(rule.spacing),
+				absorbsPrecedingEm: rule.absorbsPrecedingEm
+			};
+		},
+		finalStretchCostPerEm: style.finalStretchCostPerEm,
+		canExpandAtFinalStage: rules.canExpandAtFinalStage,
+		breakPenalty: rules.breakPenalty,
+		canHang: rules.canHang
+	};
+} }.of(defaultJapaneseTypesettingRules, defaultBookStyle);
+const InlineSpan = { schema: readonlyObject({
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0))
+}) };
+const MeasuredCluster = { schema: readonlyObject({
+	textRange: MeasurementTextRange.schema,
+	layoutSpan: InlineSpan.schema,
+	renderSpan: InlineSpan.schema
+}) };
+//#endregion
+//#region src/composer/run-measurement.ts
+const advanceEm = v.pipe(v.number(), v.finite(), v.minValue(0));
+const RunMeasurementSchema = v.variant("kind", [readonlyObject({
+	kind: v.literal("advance"),
+	advanceEm
+}), readonlyObject({
+	kind: v.literal("clustered"),
+	advanceEm,
+	clusters: readonlyArray(MeasuredCluster.schema)
+})]);
+const RunMeasurement = {
+	schema: RunMeasurementSchema,
+	parseFor: (request, raw) => {
+		const result = v.safeParse(RunMeasurementSchema, raw);
+		if (!result.success) return void 0;
+		const measurement = result.output;
+		if (measurement.kind === "advance") return measurement;
+		const boundaries = new Set([...graphemeSegmenter.segment(request.text)].map(({ index }) => index));
+		boundaries.add(request.text.length);
+		let textEnd = 0;
+		let layoutEnd = 0;
+		for (const cluster of measurement.clusters) {
+			const { textRange, layoutSpan } = cluster;
+			if (textRange.start !== textEnd || textRange.end <= textRange.start || !boundaries.has(textRange.start) || !boundaries.has(textRange.end) || Math.abs(layoutSpan.offsetEm - layoutEnd) > 1e-9) return void 0;
+			textEnd = textRange.end;
+			layoutEnd = layoutSpan.offsetEm + layoutSpan.advanceEm;
+		}
+		return textEnd === request.text.length && Math.abs(layoutEnd - measurement.advanceEm) <= 1e-9 ? measurement : void 0;
+	}
+};
+//#endregion
+//#region src/composer/internal/measurement-session.ts
+const MeasurementSession = { create: (provider, settings) => {
+	const cache = /* @__PURE__ */ new Map();
+	const get = (text, kind, presentation = "mixed") => {
+		const request = kind === "base" ? {
+			text,
+			kind,
+			presentation,
+			fontPreset: settings.appearance.fontPreset,
+			fontSizePt: settings.appearance.fontSizePt,
+			scale: 1,
+			writingMode: "vertical-rl"
+		} : {
+			text,
+			kind,
+			presentation: "mixed",
+			fontPreset: settings.appearance.fontPreset,
+			fontSizePt: settings.appearance.fontSizePt,
+			scale: defaultBookStyle.annotation.sizeEm,
+			writingMode: "vertical-rl"
+		};
+		const key = JSON.stringify(request);
+		if (cache.has(key)) return cache.get(key);
+		const measurement = RunMeasurement.parseFor(request, provider(request));
+		cache.set(key, measurement);
+		return measurement;
+	};
+	return {
+		get,
+		pieces: (text, kind, presentation) => {
+			const full = get(text, kind, presentation);
+			if (full === void 0) return void 0;
+			if (full.kind === "clustered") return full.clusters.map((cluster) => ({
+				textRange: cluster.textRange,
+				layoutSpan: cluster.layoutSpan,
+				renderSpan: cluster.renderSpan,
+				value: text.slice(cluster.textRange.start, cluster.textRange.end)
+			}));
+			const segments = [...graphemeSegmenter.segment(text)];
+			if (kind === "base" && presentation === "tate-chu-yoko") {
+				const advanceEm = full.advanceEm / segments.length;
+				return segments.map(({ segment, index }, position) => {
+					const span = {
+						offsetEm: position * advanceEm,
+						advanceEm
+					};
+					return {
+						value: segment,
+						textRange: MeasurementTextRange.of({
+							start: index,
+							end: index + segment.length
+						}),
+						layoutSpan: span,
+						renderSpan: span
+					};
+				});
+			}
+			const pieces = [];
+			let offsetEm = 0;
+			for (const { segment, index } of segments) {
+				const measured = get(segment, kind, presentation);
+				if (measured === void 0) return void 0;
+				const cluster = measured.kind === "clustered" ? measured.clusters[0] : void 0;
+				pieces.push({
+					value: segment,
+					textRange: MeasurementTextRange.of({
+						start: index,
+						end: index + segment.length
+					}),
+					layoutSpan: {
+						offsetEm,
+						advanceEm: measured.advanceEm
+					},
+					renderSpan: {
+						offsetEm: offsetEm + (cluster?.renderSpan.offsetEm ?? 0),
+						advanceEm: cluster?.renderSpan.advanceEm ?? measured.advanceEm
+					}
+				});
+				offsetEm += measured.advanceEm;
+			}
+			return pieces;
+		}
+	};
+} };
+//#endregion
+//#region src/composer/source-placement.ts
+const memberRange = v.pipe(ManuscriptRange.schema, v.check(({ graphemes }) => graphemes.end === graphemes.start + 1));
+const SourcePlacement = {
+	schema: v.variant("kind", [readonlyObject({
+		kind: v.literal("exact"),
+		range: memberRange,
+		layoutSpan: InlineSpan.schema
+	}), readonlyObject({
+		kind: v.literal("shared"),
+		ranges: v.pipe(readonlyArray(memberRange), v.minLength(2)),
+		layoutSpan: InlineSpan.schema
+	})]),
+	ranges: (placement) => placement.kind === "exact" ? [placement.range] : placement.ranges
+};
+//#endregion
+//#region src/composer/internal/render-unit-contract.ts
+const renderUnitEntries = {
+	value: v.pipe(v.string(), v.nonEmpty()),
+	range: ManuscriptRange.schema,
+	layoutSpan: InlineSpan.schema,
+	renderSpan: InlineSpan.schema,
+	sources: v.pipe(readonlyArray(SourcePlacement.schema), v.nonEmpty())
+};
+function validRenderSources(unit) {
+	const ranges = unit.sources.flatMap(SourcePlacement.ranges);
+	if ([...graphemeSegmenter.segment(unit.value)].length !== ranges.length || unit.value.length !== unit.range.display.end - unit.range.display.start || ranges[0]?.source.start !== unit.range.source.start) return false;
+	let end = unit.range.graphemes.start;
+	let displayEnd = unit.range.display.start;
+	let sourceEnd = unit.range.source.start;
+	let layoutEnd = unit.layoutSpan.offsetEm;
+	for (const placement of unit.sources) {
+		if (Math.abs(placement.layoutSpan.offsetEm - layoutEnd) > 1e-9) return false;
+		layoutEnd += placement.layoutSpan.advanceEm;
+		for (const range of SourcePlacement.ranges(placement)) {
+			if (range.graphemes.start !== end || range.display.start !== displayEnd || range.source.start < sourceEnd) return false;
+			end = range.graphemes.end;
+			displayEnd = range.display.end;
+			sourceEnd = range.source.end;
+		}
+	}
+	return end === unit.range.graphemes.end && displayEnd === unit.range.display.end && sourceEnd === unit.range.source.end && Math.abs(layoutEnd - unit.layoutSpan.offsetEm - unit.layoutSpan.advanceEm) <= 1e-9;
+}
+const CombinedGlyphUnit = { schema: v.pipe(readonlyObject({
+	...renderUnitEntries,
+	kind: v.literal("combined-glyph"),
+	presentation: v.picklist(["tate-chu-yoko", "sideways"]),
+	disposition: v.literal("placed")
+}), v.check((unit) => unit.range.graphemes.end >= unit.range.graphemes.start + 2 && validRenderSources(unit))) };
+//#endregion
+//#region src/composer/composed-inline-item.ts
+const signedEm = () => v.pipe(v.number(), v.finite());
+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 ComposedGlue = { schema: v.union([GeneratedGlueItemSchema, SourceGlueItemSchema]) };
+const ComposedKern = { schema: KernItemSchema };
+const SuppressedInlineItem = { schema: SuppressedItemSchema };
+const SingleGlyphUnit = { schema: v.pipe(readonlyObject({
+	...renderUnitEntries,
+	kind: v.literal("glyph"),
+	presentation: v.picklist([
+		"mixed",
+		"upright",
+		"sideways"
+	]),
+	disposition: v.picklist(["placed", "hanging"])
+}), v.check((unit) => unit.range.graphemes.end === unit.range.graphemes.start + 1 && validRenderSources(unit)), v.check((unit) => unit.disposition !== "hanging" || unit.layoutSpan.advanceEm === 0)) };
+const PositionedInlineItem = {
+	schema: v.union([
+		SingleGlyphUnit.schema,
+		CombinedGlyphUnit.schema,
+		ComposedGlue.schema,
+		ComposedKern.schema,
+		SuppressedInlineItem.schema
+	]),
+	isRenderUnit: (item) => item.kind === "glyph" || item.kind === "combined-glyph"
+};
+//#endregion
+//#region src/composer/internal/novel-source-contract.ts
+function sameRange(left, right) {
+	return left.source.start === right.source.start && left.source.end === right.source.end && left.display.start === right.display.start && left.display.end === right.display.end && left.graphemes.start === right.graphemes.start && left.graphemes.end === right.graphemes.end;
+}
+function rangeKey(range) {
+	return `${range.source.start}:${range.source.end}:${range.display.start}:${range.display.end}:${range.graphemes.start}:${range.graphemes.end}`;
+}
+const NovelSourceContract = { matches: (manuscript, lines) => {
+	const expected = manuscript.graphemes.filter(({ value }) => ![
+		"\n",
+		"\r",
+		"\r\n"
+	].includes(value));
+	const members = new Map(expected.map((grapheme) => [grapheme.range.graphemes.start, grapheme]));
+	const seen = /* @__PURE__ */ new Set();
+	for (const line of lines) for (const item of line.items) {
+		const ranges = PositionedInlineItem.isRenderUnit(item) ? item.sources.flatMap(SourcePlacement.ranges) : item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : [];
+		if (ranges.length === 0) continue;
+		if (!("value" in item) || item.value !== manuscript.displayText.slice(item.range.display.start, item.range.display.end)) return false;
+		for (const range of ranges) {
+			const member = members.get(range.graphemes.start);
+			if (member === void 0 || seen.has(range.graphemes.start) || !sameRange(member.range, range)) return false;
+			seen.add(range.graphemes.start);
+		}
+	}
+	if (seen.size !== expected.length) return false;
+	const readings = /* @__PURE__ */ new Map();
+	for (const { annotations } of lines) for (const fragment of annotations) {
+		if (fragment.kind !== "ruby") continue;
+		const key = rangeKey(fragment.annotationRange);
+		const parts = readings.get(key);
+		if (parts === void 0) readings.set(key, [fragment.reading]);
+		else parts.push(fragment.reading);
+	}
+	return manuscript.annotations.every((annotation) => {
+		if (annotation.kind !== "ruby") return true;
+		const reading = annotation.reading.kind === "group" ? annotation.reading.text : annotation.reading.segments.join("");
+		return (readings.get(rangeKey(annotation.range)) ?? []).join("") === reading;
+	});
+} };
+//#endregion
+//#region src/composer/internal/paragraph-evaluation.ts
+const EPSILON$3 = 1e-9;
+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.deformationCost > EPSILON$3 ? 1 : 0
+	};
+	return {
+		score: [
+			modeCounts.forced,
+			modeCounts.stretched,
+			modeCounts.hanging,
+			modeCounts.shrunk,
+			line.deformationCost,
+			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]
+	];
+}
+const defaultParagraphEvaluation = { scoreFor };
+//#endregion
+//#region src/composer/internal/paragraph-layout.ts
+const EPSILON$2 = 1e-9;
+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;
+}
+/**
+* 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;
+}
+/**
+* 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.key);
+	}
+	return result.reverse();
+}
+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, 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$2) return difference < 0;
+	}
+	return compareBreaks(breaksOf(candidateState, states), breaksOf(current, states)) < 0;
+}
+function layoutParagraph(atoms, lineLengthEm, resolveCandidate, boundaryAllowed, evaluation = defaultParagraphEvaluation) {
+	if (atoms.length === 0) return [];
+	const stateKey = (cursor, fitness) => `${cursor}:${fitness}`;
+	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[stateKey(0, 0), {
+		score: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		fitness: 0,
+		cursor: 0,
+		previous: null,
+		line: null
+	}]])]]);
+	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()) {
+				const key = stateKey(state.cursor, state.fitness);
+				if (isBetter(state, terminalStates.get(key), states)) terminalStates.set(key, state);
+			}
+			states.set(atoms.length, terminalStates);
+			continue;
+		}
+		const candidatesByEnd = /* @__PURE__ */ new Map();
+		for (const state of activeStates.values()) {
+			let minimumSizeEm = 0;
+			for (let end = contentStart + 1; end <= atoms.length; end += 1) {
+				minimumSizeEm += atoms[end - 1]?.boxAdvanceEm ?? 0;
+				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 candidateKey = `${end}:${state.cursor}`;
+				let line = candidatesByEnd.get(candidateKey);
+				if (!candidatesByEnd.has(candidateKey)) {
+					line = resolveCandidate(start, end, state.cursor);
+					candidatesByEnd.set(candidateKey, line);
+				}
+				if (line === void 0) {
+					if (minimumSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
+					continue;
+				}
+				if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON$2 && hasEarlierBoundary(boundaryAllowed, contentStart, end)) {
+					if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
+					continue;
+				}
+				const lineScore = evaluation.scoreFor(line, state.fitness);
+				const nextState = {
+					score: addScore(state.score, lineScore.score),
+					fitness: lineScore.fitness,
+					cursor: line.nextCursor ?? 0,
+					previous: {
+						index: start,
+						key: stateKey(state.cursor, state.fitness)
+					},
+					line
+				};
+				const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
+				const nextKey = stateKey(nextState.cursor, nextState.fitness);
+				if (isBetter(nextState, statesAtEnd.get(nextKey), states)) {
+					statesAtEnd.set(nextKey, 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, states) ? 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.key);
+	}
+	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;
+}
+//#endregion
+//#region src/composer/internal/ruby-association.ts
+const RubyAssociation = {
+	collect: (annotations, graphemes) => annotations.flatMap((annotation) => {
+		if (annotation.kind !== "ruby") return [];
+		const first = graphemes[0];
+		if (first === void 0) return [];
+		const start = Math.max(0, annotation.range.graphemes.start - first.range.graphemes.start);
+		const end = Math.min(graphemes.length, annotation.range.graphemes.end - first.range.graphemes.start);
+		const indexes = Array.from({ length: Math.max(0, end - start) }, (_, index) => start + index);
+		return indexes.length === 0 ? [] : [{
+			baseRange: annotation.range,
+			reading: annotation.reading,
+			indexes
+		}];
+	}),
+	fittableInteriors: (associations, advancesEm, lineLengthEm, fittableGroups) => {
+		const interiors = /* @__PURE__ */ new Set();
+		for (const association of associations) {
+			if (association.reading.kind !== "group") continue;
+			if (fittableGroups !== void 0 && !fittableGroups.has(association)) continue;
+			const first = association.indexes[0];
+			const last = association.indexes.at(-1);
+			if (first === void 0 || last === void 0) continue;
+			if (association.indexes.reduce((total, index) => total + (advancesEm[index] ?? 0), 0) > lineLengthEm) continue;
+			for (let boundary = first + 1; boundary <= last; boundary += 1) interiors.add(boundary);
+		}
+		return interiors;
+	}
+};
+//#endregion
+//#region src/composer/internal/jukugo-ruby.ts
+const EPSILON$1 = 1e-9;
+function boundsFor(readings, edges, spacings, outer) {
+	let shiftEm = 0;
+	return readings.map((reading, index) => {
+		const spacing = spacings[index] ?? {
+			beforeEm: 0,
+			afterEm: 0
+		};
+		shiftEm += (spacings[index - 1]?.afterEm ?? 0) + spacing.beforeEm;
+		const before = index === 0 && !outer ? 0 : reading.beforeEm;
+		const after = index === readings.length - 1 && !outer ? 0 : reading.afterEm;
+		const lower = [{
+			positionEm: reading.baseOffsetEm - before - reading.beforeSpacingEm,
+			perSpacingEm: shiftEm - spacing.beforeEm
+		}];
+		const upper = [{
+			positionEm: reading.baseOffsetEm + reading.baseAdvanceEm + after + reading.afterSpacingEm - reading.readingAdvanceEm,
+			perSpacingEm: shiftEm + spacing.afterEm
+		}];
+		if (index === 0 && edges.head) {
+			const head = {
+				positionEm: reading.baseOffsetEm,
+				perSpacingEm: shiftEm
+			};
+			lower.push(head);
+			upper.push(head);
+		} else if (index === readings.length - 1 && edges.tail) {
+			const tail = {
+				positionEm: reading.baseOffsetEm + reading.baseAdvanceEm - reading.readingAdvanceEm,
+				perSpacingEm: shiftEm
+			};
+			lower.push(tail);
+			upper.push(tail);
+		}
+		return {
+			lower,
+			upper
+		};
+	});
+}
+function place$1(readings, bounds) {
+	const latest = [];
+	let following = Number.POSITIVE_INFINITY;
+	for (let index = readings.length - 1; index >= 0; index -= 1) {
+		const reading = readings[index];
+		const bound = bounds[index];
+		if (reading === void 0 || bound === void 0) return void 0;
+		const upper = Math.min(...bound.upper.map(({ positionEm }) => positionEm));
+		const position = Math.min(upper, following - reading.readingAdvanceEm);
+		if (position < Math.max(...bound.lower.map(({ positionEm }) => positionEm)) - EPSILON$1) return void 0;
+		latest[index] = position;
+		following = position;
+	}
+	const offsetsEm = [];
+	let precedingEnd = Number.NEGATIVE_INFINITY;
+	for (const [index, reading] of readings.entries()) {
+		const bound = bounds[index];
+		if (bound === void 0) return void 0;
+		const position = Math.max(precedingEnd, ...bound.lower.map(({ positionEm }) => positionEm), Math.min(reading.baseOffsetEm, latest[index] ?? reading.baseOffsetEm));
+		offsetsEm.push(position);
+		precedingEnd = position + reading.readingAdvanceEm;
+	}
+	return offsetsEm;
+}
+const JukugoRuby = { resolve: (readings, edges) => {
+	const empty = readings.map(() => ({
+		beforeEm: 0,
+		afterEm: 0
+	}));
+	for (const outer of [false, true]) {
+		const offsetsEm = place$1(readings, boundsFor(readings, edges, empty, outer));
+		if (offsetsEm !== void 0) return {
+			kind: "placed",
+			offsetsEm
+		};
+	}
+	const weights = readings.map((reading) => reading.readingAdvanceEm > reading.intrinsicBaseAdvanceEm + EPSILON$1 ? reading.readingAdvanceEm : 0);
+	const total = weights.reduce((sum, weight) => sum + weight, 0);
+	if (total <= EPSILON$1) return { kind: "refused" };
+	const shares = weights.map((weight, index) => {
+		const share = weight / total;
+		if (index === 0 && edges.head) return {
+			beforeEm: 0,
+			afterEm: share
+		};
+		if (index === readings.length - 1 && edges.tail) return {
+			beforeEm: share,
+			afterEm: 0
+		};
+		return {
+			beforeEm: share / 2,
+			afterEm: share / 2
+		};
+	});
+	const bounds = boundsFor(readings, edges, shares, true);
+	let amountEm = 0;
+	for (let start = 0; start < readings.length; start += 1) {
+		let advanceEm = 0;
+		for (let end = start; end < readings.length; end += 1) {
+			const reading = readings[end];
+			if (reading === void 0) return { kind: "refused" };
+			advanceEm += reading.readingAdvanceEm;
+			for (const lower of bounds[start]?.lower ?? []) for (const upper of bounds[end]?.upper ?? []) {
+				const missing = advanceEm - reading.readingAdvanceEm + lower.positionEm - upper.positionEm;
+				if (missing <= EPSILON$1) continue;
+				const capacity = upper.perSpacingEm - lower.perSpacingEm;
+				if (capacity <= EPSILON$1) return { kind: "refused" };
+				amountEm = Math.max(amountEm, missing / capacity);
+			}
+		}
+	}
+	if (amountEm <= EPSILON$1) return { kind: "refused" };
+	return {
+		kind: "needs-spacing",
+		spacings: shares.map((share) => ({
+			beforeEm: share.beforeEm * amountEm,
+			afterEm: share.afterEm * amountEm
+		}))
+	};
+} };
+//#endregion
+//#region src/composer/internal/ruby-boundary.ts
+const RubyBoundary = { overhang: (neighbor, side, spacingEm, rubySizeEm) => {
+	if (neighbor === void 0 || neighbor.effectiveClass === "cl-22" || neighbor.effectiveClass === "cl-23") return 0;
+	const { lexicalClass, advanceEm } = neighbor;
+	if ([
+		"cl-08",
+		"cl-10",
+		"cl-11",
+		"cl-14",
+		"cl-15",
+		"cl-16"
+	].some((value) => value === lexicalClass)) return Math.min(rubySizeEm, advanceEm);
+	if ([
+		"cl-05",
+		"cl-24",
+		"cl-25",
+		"cl-27"
+	].some((value) => value === lexicalClass)) return Math.min(rubySizeEm / 2, Math.max(0, spacingEm));
+	const closing = lexicalClass === "cl-02" || lexicalClass === "cl-06" || lexicalClass === "cl-07";
+	if (side === "before" && closing || side === "after" && lexicalClass === "cl-01") return Math.min(rubySizeEm, Math.max(0, spacingEm));
+	if (side === "after" && closing || side === "before" && lexicalClass === "cl-01") return Math.min(rubySizeEm, advanceEm);
+	return 0;
+} };
+//#endregion
+//#region src/composer/internal/ruby-line-layout.ts
+const EPSILON = 1e-9;
+const { sizeEm: rubySizeEm } = defaultBookStyle.annotation;
+function positions(bases, line) {
+	const boxes = new Map(line.boxAdjustments?.map((box) => [box.index, box]));
+	const gaps = new Map(line.pairSpacings.map((gap) => [gap.boundary, gap.widthEm]));
+	const spaces = new Map(line.characterSpacings.map((space) => [space.index, space.widthEm]));
+	const offsets = /* @__PURE__ */ new Map();
+	let offsetEm = 0;
+	for (let index = line.contentStart; index < line.end; index += 1) {
+		offsetEm += gaps.get(index) ?? 0;
+		const advanceEm = index === line.hangingIndex ? 0 : spaces.get(index) ?? boxes.get(index)?.advanceEm ?? bases[index]?.advanceEm ?? 0;
+		offsets.set(index, {
+			offsetEm,
+			advanceEm
+		});
+		offsetEm += advanceEm;
+	}
+	return {
+		offsets,
+		gaps
+	};
+}
+function allowances(bases, segment, line, gaps, ownSpacing = {
+	beforeEm: 0,
+	afterEm: 0
+}) {
+	const first = segment.association.indexes[0] ?? segment.start;
+	const last = segment.association.indexes.at(-1) ?? segment.end - 1;
+	const jukugo = segment.association.reading.kind === "jukugo";
+	return {
+		before: jukugo && segment.start > first && segment.start > line.contentStart ? rubySizeEm : RubyBoundary.overhang(segment.start > line.contentStart ? bases[segment.start - 1] : void 0, "before", Math.max(0, (gaps.get(segment.start) ?? 0) - ownSpacing.beforeEm), rubySizeEm),
+		after: jukugo && segment.end <= last && segment.end < line.end ? rubySizeEm : RubyBoundary.overhang(segment.end < line.end ? bases[segment.end] : void 0, "after", Math.max(0, (gaps.get(segment.end) ?? 0) - ownSpacing.afterEm), rubySizeEm)
+	};
+}
+function readingAdvance(segment) {
+	return segment.pieces.reduce((sum, piece) => sum + piece.layoutSpan.advanceEm, 0);
+}
+function place(segment, baseOffsetEm, baseAdvanceEm, before, after, resolvedOffsetEm) {
+	const total = readingAdvance(segment);
+	const overhang = total > baseAdvanceEm ? Math.min(total - baseAdvanceEm, before + after) : 0;
+	const leading = Math.min(before, overhang / 2 + Math.max(0, overhang / 2 - after));
+	const edgeGap = segment.association.reading.kind !== "jukugo" && total < baseAdvanceEm && segment.pieces.length > 0 ? (baseAdvanceEm - total) / (2 * segment.pieces.length) : 0;
+	let offsetEm = resolvedOffsetEm ?? baseOffsetEm - leading + edgeGap;
+	return {
+		segment,
+		items: segment.pieces.map((piece, index) => {
+			const item = {
+				value: piece.value,
+				textRange: piece.textRange,
+				placement: {
+					side: "before",
+					inlineSpan: {
+						offsetEm: offsetEm + piece.renderSpan.offsetEm - piece.layoutSpan.offsetEm,
+						advanceEm: piece.renderSpan.advanceEm
+					},
+					blockOffsetEm: -rubySizeEm,
+					blockSizeEm: rubySizeEm
+				}
+			};
+			offsetEm += piece.layoutSpan.advanceEm;
+			if (index < segment.pieces.length - 1) offsetEm += 2 * edgeGap;
+			return item;
+		})
+	};
+}
+const RubyLineLayout = {
+	index: (segments) => {
+		const byStart = /* @__PURE__ */ new Map();
+		for (const segment of segments) {
+			const sameStart = byStart.get(segment.start);
+			if (sameStart === void 0) byStart.set(segment.start, [segment]);
+			else sameStart.push(segment);
+		}
+		return byStart;
+	},
+	resolve: (bases, segments, start, end, resolve, assignedSegments = []) => {
+		const selected = [];
+		for (let index = start; index < end; index += 1) for (const segment of segments.get(index) ?? []) if (segment.end <= end) selected.push(segment);
+		selected.push(...assignedSegments);
+		selected.sort((left, right) => left.start - right.start);
+		const jukugoCounts = /* @__PURE__ */ new Map();
+		for (const segment of selected) if (segment.association.reading.kind === "jukugo") jukugoCounts.set(segment.association, (jukugoCounts.get(segment.association) ?? 0) + 1);
+		const expansions = /* @__PURE__ */ new Map();
+		const extraGaps = /* @__PURE__ */ new Map();
+		const jukugoSpacings = /* @__PURE__ */ new Map();
+		const metrics = () => {
+			const boxAdjustments = [];
+			for (const [index, extraEm] of expansions) {
+				const base = bases[index];
+				if (base !== void 0) boxAdjustments.push({
+					index,
+					advanceEm: base.advanceEm + extraEm,
+					renderOffsetEm: base.renderOffsetEm + extraEm / 2
+				});
+			}
+			return {
+				boxAdjustments,
+				extraSpacings: [...extraGaps].map(([boundary, widthEm]) => ({
+					boundary,
+					widthEm
+				}))
+			};
+		};
+		let line = resolve();
+		for (let pass = 0; pass <= selected.length * 2 + 2; pass += 1) {
+			const { offsets, gaps } = positions(bases, line);
+			const placements = [];
+			let changed = false;
+			for (const segment of selected) {
+				const first = offsets.get(segment.start);
+				const last = offsets.get(segment.end - 1);
+				if (first === void 0 || last === void 0) return void 0;
+				const span = last.offsetEm + last.advanceEm - first.offsetEm;
+				const { before, after } = allowances(bases, segment, line, gaps);
+				const missing = readingAdvance(segment) - span - before - after;
+				const sharedJukugo = (jukugoCounts.get(segment.association) ?? 0) > 1;
+				if (missing > EPSILON && !sharedJukugo) {
+					const indexes = Array.from({ length: segment.end - segment.start }, (_, index) => segment.start + index).filter((index) => bases[index]?.sourceGap === false && bases[index].advanceEm > 0);
+					if (indexes.length === 0) return void 0;
+					for (const index of indexes) expansions.set(index, (expansions.get(index) ?? 0) + missing / indexes.length);
+					changed = true;
+				}
+				placements.push(place(segment, first.offsetEm, span, before, after));
+			}
+			if (changed) {
+				line = resolve(metrics());
+				continue;
+			}
+			for (let index = 0; index < selected.length; index += 1) {
+				const first = selected[index];
+				if (first?.association.reading.kind !== "jukugo") continue;
+				const group = [first];
+				while (selected[index + group.length]?.association === first.association) {
+					const next = selected[index + group.length];
+					if (next === void 0) break;
+					if (next.start < (group.at(-1)?.end ?? next.start)) return void 0;
+					group.push(next);
+				}
+				const readings = group.flatMap((segment) => {
+					const baseStart = offsets.get(segment.start);
+					const baseEnd = offsets.get(segment.end - 1);
+					if (baseStart === void 0 || baseEnd === void 0) return [];
+					const baseAdvanceEm = baseEnd.offsetEm + baseEnd.advanceEm - baseStart.offsetEm;
+					const total = readingAdvance(segment);
+					const spacing = jukugoSpacings.get(segment);
+					const limits = allowances(bases, segment, line, gaps, spacing);
+					return [{
+						baseOffsetEm: baseStart.offsetEm,
+						baseAdvanceEm,
+						intrinsicBaseAdvanceEm: bases.slice(segment.start, segment.end).reduce((sum, base) => sum + base.advanceEm, 0),
+						readingAdvanceEm: total,
+						beforeEm: limits.before,
+						afterEm: limits.after,
+						beforeSpacingEm: spacing?.beforeEm ?? 0,
+						afterSpacingEm: spacing?.afterEm ?? 0
+					}];
+				});
+				const result = JukugoRuby.resolve(readings, {
+					head: first.start === line.contentStart,
+					tail: group.at(-1)?.end === line.end
+				});
+				if (result.kind === "refused") return void 0;
+				if (result.kind === "needs-spacing") {
+					for (const [groupIndex, spacing] of result.spacings.entries()) {
+						const segment = group[groupIndex];
+						if (segment === void 0) return void 0;
+						const existing = jukugoSpacings.get(segment);
+						jukugoSpacings.set(segment, {
+							beforeEm: (existing?.beforeEm ?? 0) + spacing.beforeEm,
+							afterEm: (existing?.afterEm ?? 0) + spacing.afterEm
+						});
+						for (const [boundary, widthEm] of [[segment.start, spacing.beforeEm], [segment.end, spacing.afterEm]]) if (widthEm > EPSILON) extraGaps.set(boundary, (extraGaps.get(boundary) ?? 0) + widthEm);
+					}
+					changed = true;
+				} else for (const [groupIndex, segment] of group.entries()) {
+					const reading = readings[groupIndex];
+					const offsetEm = result.offsetsEm[groupIndex];
+					if (reading === void 0 || offsetEm === void 0) return void 0;
+					placements[index + groupIndex] = place(segment, reading.baseOffsetEm, reading.baseAdvanceEm, reading.beforeEm, reading.afterEm, offsetEm);
+				}
+				index += group.length - 1;
+			}
+			if (changed) {
+				line = resolve(metrics());
+				continue;
+			}
+			for (let index = 1; index < placements.length; index += 1) {
+				const left = placements[index - 1];
+				const right = placements[index];
+				const leftItem = left?.items.at(-1);
+				const rightItem = right?.items[0];
+				if (left === void 0 || right === void 0 || leftItem === void 0 || rightItem === void 0) continue;
+				const clearance = right.segment.start > left.segment.end ? rubySizeEm : 0;
+				const missing = leftItem.placement.inlineSpan.offsetEm + leftItem.placement.inlineSpan.advanceEm + clearance - rightItem.placement.inlineSpan.offsetEm;
+				if (missing <= EPSILON) continue;
+				if (right.segment.start < left.segment.end) return void 0;
+				extraGaps.set(right.segment.start, (extraGaps.get(right.segment.start) ?? 0) + missing);
+				changed = true;
+			}
+			if (!changed) return {
+				line: {
+					...line,
+					boxAdjustments: metrics().boxAdjustments
+				},
+				placements
+			};
+			line = resolve(metrics());
+		}
+	}
+};
+//#endregion
+//#region src/composer/internal/source-space.ts
+const SourceSpace = { collect: (graphemes, advancesEm) => {
+	const gaps = new Set(questionOrExclamationSpacings(graphemes.map(({ value }) => value).join("")).filter((spacing) => spacing.kind === "valid").map(({ gap }) => gap.start));
+	let offset = 0;
+	return graphemes.flatMap((grapheme, index) => {
+		const separator = gaps.has(offset);
+		offset += grapheme.value.length;
+		if (separator) return [{
+			grapheme,
+			index,
+			purpose: "question-or-exclamation-separator",
+			naturalWidthEm: advancesEm[index] ?? 0,
+			edgeBehavior: "suppress"
+		}];
+		if (grapheme.value === "　") return [{
+			grapheme,
+			index,
+			purpose: "ideographic",
+			naturalWidthEm: advancesEm[index] ?? 0,
+			edgeBehavior: "preserve"
+		}];
+		if (grapheme.value === " ") return [{
+			grapheme,
+			index,
+			purpose: "western-word",
+			naturalWidthEm: 1 / 3,
+			edgeBehavior: "zero"
+		}];
+		return [];
+	});
+} };
+//#endregion
+//#region src/appearance/paper-size.ts
+const PAPER_SIZES = {
+	a4: {
+		id: "a4",
+		label: "A4",
+		widthMm: 210,
+		heightMm: 297
+	},
+	a5: {
+		id: "a5",
+		label: "A5",
+		widthMm: 148,
+		heightMm: 210
+	},
+	a6: {
+		id: "a6",
+		label: "A6（文庫）",
+		widthMm: 105,
+		heightMm: 148
+	},
+	"jis-b5": {
+		id: "jis-b5",
+		label: "B5（JIS）",
+		widthMm: 182,
+		heightMm: 257
+	},
+	"jis-b6": {
+		id: "jis-b6",
+		label: "B6（JIS）",
+		widthMm: 128,
+		heightMm: 182
+	},
+	shinsho: {
+		id: "shinsho",
+		label: "新書",
+		widthMm: 106,
+		heightMm: 173
+	}
+};
+const PaperSize = {
+	of: (id) => PAPER_SIZES[id],
+	all: Object.values(PAPER_SIZES)
+};
+//#endregion
+//#region src/internal/length.ts
+const PT_PER_MM = 72 / 25.4;
+function ptToMm(pt) {
+	return pt / PT_PER_MM;
+}
+function mmToPt(mm) {
+	return mm * PT_PER_MM;
+}
+//#endregion
+//#region src/composer/manuscript-geometry.ts
+const STAGE_GAP_CELLS = 2;
+const LINE_GAP_CELLS = .5;
+const nonNegativeLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const ManuscriptGeometrySchema = readonlyObject({
+	paperWidthMm: nonNegativeLength(),
+	paperHeightMm: nonNegativeLength(),
+	cellSizeMm: nonNegativeLength(),
+	lineGapMm: nonNegativeLength(),
+	fontSizePt: FontSizePt.schema,
+	contentWidthMm: nonNegativeLength(),
+	contentHeightMm: nonNegativeLength(),
+	marginInlineMm: v.pipe(v.number(), v.finite()),
+	marginBlockMm: v.pipe(v.number(), v.finite()),
+	fitsPaper: v.boolean()
+});
+/**
+* Every stage stacked vertically, plus the gap between adjacent stages.
+*/
+function contentHeightInEm(flow) {
+	return flow.stagesPerPage * flow.lineLengthEm + STAGE_GAP_CELLS * (flow.stagesPerPage - 1);
+}
+/**
+* Every vertical line side by side, plus the gap between adjacent lines.
+*/
+function contentWidthInEm(flow) {
+	return flow.linesPerStage + LINE_GAP_CELLS * (flow.linesPerStage - 1);
+}
+const ManuscriptGeometry = {
+	schema: ManuscriptGeometrySchema,
+	of: (flow, appearance) => {
+		const paper = PaperSize.of(appearance.paperSize);
+		const cellSizeMm = ptToMm(appearance.fontSizePt);
+		const contentWidthMm = contentWidthInEm(flow) * cellSizeMm;
+		const contentHeightMm = contentHeightInEm(flow) * cellSizeMm;
+		const marginInlineMm = (paper.widthMm - contentWidthMm) / 2;
+		const marginBlockMm = (paper.heightMm - contentHeightMm) / 2;
+		return {
+			paperWidthMm: paper.widthMm,
+			paperHeightMm: paper.heightMm,
+			cellSizeMm,
+			lineGapMm: LINE_GAP_CELLS * cellSizeMm,
+			fontSizePt: appearance.fontSizePt,
+			contentWidthMm,
+			contentHeightMm,
+			marginInlineMm,
+			marginBlockMm,
+			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
+		};
+	},
+	/**
+	* The largest step-aligned point size whose text area still fits the paper.
+	*/
+	maxFontSizePt: (flow, paperSizeId) => {
+		const paper = PaperSize.of(paperSizeId);
+		const maxCellSizeMm = Math.min(paper.widthMm / contentWidthInEm(flow), paper.heightMm / contentHeightInEm(flow));
+		const steps = Math.floor(mmToPt(maxCellSizeMm) / FontSizePt.range.step + 1e-9);
+		const aligned = Math.round(steps * FontSizePt.range.step * 1e3) / 1e3;
+		return Math.min(FontSizePt.range.max, Math.max(FontSizePt.range.min, aligned));
+	}
+};
+const CompositionStatistics = { schema: readonlyObject({
+	chars: nonNegativeInteger(),
+	sourceLines: nonNegativeInteger(),
+	pages: nonNegativeInteger()
+}) };
+const AnnotationPlacement = { schema: readonlyObject({
+	side: v.picklist(["before", "after"]),
+	inlineSpan: InlineSpan.schema,
+	blockOffsetEm: v.pipe(v.number(), v.finite()),
+	blockSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0))
+}) };
+//#endregion
+//#region src/composer/composed-annotation-fragment.ts
+const common = {
+	annotationRange: ManuscriptRange.schema,
+	fragmentRange: ManuscriptRange.schema,
+	continuation: v.picklist([
+		"whole",
+		"start",
+		"middle",
+		"end"
+	])
+};
+const readingItem = readonlyObject({
+	value: v.pipe(v.string(), v.nonEmpty()),
+	textRange: MeasurementTextRange.schema,
+	placement: AnnotationPlacement.schema
+});
+const ComposedAnnotationFragment = { schema: v.pipe(v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("bold"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("italic"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("emphasis"),
+		mark: v.string(),
+		placements: readonlyArray(AnnotationPlacement.schema),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("ruby"),
+		rubyKind: RubyKind.schema,
+		reading: v.string(),
+		readingItems: readonlyArray(readingItem),
+		...common
+	})
+]), v.check((fragment) => {
+	const { annotationRange, fragmentRange } = fragment;
+	if (fragmentRange.graphemes.start < annotationRange.graphemes.start || fragmentRange.graphemes.end > annotationRange.graphemes.end || fragmentRange.source.start < annotationRange.source.start || fragmentRange.source.end > annotationRange.source.end || fragmentRange.display.start < annotationRange.display.start || fragmentRange.display.end > annotationRange.display.end) return false;
+	const starts = fragmentRange.graphemes.start === annotationRange.graphemes.start;
+	const ends = fragmentRange.graphemes.end === annotationRange.graphemes.end;
+	const continuation = starts && ends ? "whole" : starts ? "start" : ends ? "end" : "middle";
+	if (fragment.continuation !== continuation) return false;
+	if (fragment.kind !== "ruby") return true;
+	const boundaries = new Set([...graphemeSegmenter.segment(fragment.reading)].map(({ index }) => index));
+	boundaries.add(fragment.reading.length);
+	let end = 0;
+	for (const item of fragment.readingItems) {
+		if (item.textRange.start !== end || item.textRange.end <= end || !boundaries.has(item.textRange.end) || fragment.reading.slice(end, item.textRange.end) !== item.value) return false;
+		end = item.textRange.end;
+	}
+	return end === fragment.reading.length;
+})) };
+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") })
+]) };
+const NovelLine = {
+	schema: v.pipe(readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		inlineSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		items: readonlyArray(PositionedInlineItem.schema),
+		break: LineBreakResult.schema,
+		annotations: readonlyArray(ComposedAnnotationFragment.schema)
+	}), v.check((line) => {
+		const ranges = line.items.flatMap((item) => PositionedInlineItem.isRenderUnit(item) ? item.sources.flatMap(SourcePlacement.ranges) : item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
+		if (line.range === null) return ranges.length === 0 && line.items.length === 0 && line.annotations.length === 0 && line.inlineSizeEm === 0;
+		ranges.sort((left, right) => left.graphemes.start - right.graphemes.start);
+		const first = ranges[0];
+		const last = ranges.at(-1);
+		if (first === void 0 || last === void 0) return false;
+		let end = line.range.graphemes.start;
+		for (const range of ranges) {
+			if (range.graphemes.start !== end) return false;
+			end = range.graphemes.end;
+		}
+		return end === line.range.graphemes.end && first.source.start === line.range.source.start && last.source.end === line.range.source.end && first.display.start === line.range.display.start && last.display.end === line.range.display.end && line.annotations.every(({ fragmentRange }) => line.range !== null && fragmentRange.graphemes.start >= line.range.graphemes.start && fragmentRange.graphemes.end <= line.range.graphemes.end && fragmentRange.source.start >= line.range.source.start && fragmentRange.source.end <= line.range.source.end && fragmentRange.display.start >= line.range.display.start && fragmentRange.display.end <= line.range.display.end);
+	})),
+	empty: () => ({
+		range: null,
+		inlineSizeEm: 0,
+		items: [],
+		break: { kind: "paragraph-end" },
+		annotations: []
+	})
+};
+const NovelStage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		lines: readonlyArray(NovelLine.schema)
+	}),
+	of: (lines) => ({
+		lines,
+		range: ManuscriptRange.merge(lines.map(({ range }) => range))
+	})
+};
+const NovelPage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		stages: readonlyArray(NovelStage.schema)
+	}),
+	of: (stages) => ({
+		stages,
+		range: ManuscriptRange.merge(stages.map(({ range }) => range))
+	})
+};
+const NovelLayout = { schema: readonlyObject({
+	pages: readonlyArray(NovelPage.schema),
+	geometry: ManuscriptGeometry.schema,
+	stats: CompositionStatistics.schema
+}) };
+//#endregion
+//#region src/composer/run-measurer.ts
+function graphemeWidth(grapheme) {
+	let width = 1;
+	for (const character of grapheme) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0) {
+			const characterWidth = "！？‼⁇⁈⁉".includes(character) ? 2 : eastAsianWidth(codePoint, { ambiguousAsWide: true });
+			width = Math.max(width, characterWidth);
+		}
+	}
+	return width / 2;
+}
+/**
+* Deterministic DOM-independent metrics. Aggregate width does not imply a shared cluster.
+*/
+const logicalRunMeasurer = (request) => {
+	const segments = [...graphemeSegmenter.segment(request.text)];
+	return {
+		kind: "advance",
+		advanceEm: (request.kind === "base" && request.presentation === "upright" ? segments.length : request.kind === "base" && request.presentation === "tate-chu-yoko" ? 1 : segments.reduce((total, { segment }) => total + graphemeWidth(segment), 0)) * request.scale
+	};
+};
+//#endregion
+//#region src/composer/novel-composer.ts
+const COMPOSER_ID = NamespacedId.of("kg/novel");
+const TYPESETTING_PROFILE = defaultJapaneseTypesettingProfile;
+function displayedLines(graphemes) {
+	const lines = [[]];
+	let endedWithLineBreak = false;
+	for (const grapheme of graphemes) {
+		if (grapheme.value === "\n" || grapheme.value === "\r" || grapheme.value === "\r\n") {
+			lines.push([]);
+			endedWithLineBreak = true;
+			continue;
+		}
+		lines.at(-1)?.push(grapheme);
+		endedWithLineBreak = false;
+	}
+	if (lines.length > 1 && endedWithLineBreak) lines.pop();
+	return lines;
+}
+function measureSourceLine(sourceLine, annotations, measurements) {
+	const runs = CompositionRun.recognize(sourceLine);
+	const rubyAssociations = RubyAssociation.collect(annotations, sourceLine);
+	const atoms = [];
+	for (const [runIndex, run] of runs.entries()) {
+		const text = run.members.map(({ value }) => value).join("");
+		const pieces = measurements.pieces(text, "base", run.presentation);
+		if (pieces === void 0) return void 0;
+		const combineRun = run.presentation === "tate-chu-yoko" || pieces.length < run.members.length;
+		let memberStart = 0;
+		for (const piece of pieces) {
+			const memberCount = [...graphemeSegmenter.segment(piece.value)].length;
+			const members = run.members.slice(memberStart, memberStart + memberCount);
+			const clusterRange = memberCount > 1 ? ManuscriptRange.merge(members.map(({ range }) => range)) : null;
+			for (const [memberIndex, grapheme] of members.entries()) {
+				const first = memberIndex === 0;
+				const renderAdvanceEm = first ? piece.renderSpan.advanceEm : 0;
+				const measuredAdvanceEm = first ? piece.layoutSpan.advanceEm : 0;
+				const characterClass = TYPESETTING_PROFILE.classify({
+					value: grapheme.value,
+					presentation: run.presentation
+				});
+				const metrics = TYPESETTING_PROFILE.boxMetrics(characterClass, measuredAdvanceEm);
+				atoms.push({
+					grapheme,
+					runIndex,
+					characterClass,
+					intrinsicBoxAdvanceEm: metrics.advanceEm,
+					boxAdvanceEm: metrics.advanceEm,
+					renderAdvanceEm,
+					renderOffsetEm: metrics.renderOffsetEm + (first ? piece.renderSpan.offsetEm - piece.layoutSpan.offsetEm : 0),
+					presentation: run.presentation,
+					clusterRange,
+					combineRun
+				});
+			}
+			memberStart += memberCount;
+		}
+	}
+	const candidateReadings = [];
+	const groupReadings = [];
+	const baseAdvances = atoms.map((atom) => atom.boxAdvanceEm);
+	const physicalRange = (first, last) => {
+		const left = atoms[first];
+		const right = atoms[last];
+		while (first > 0 && left?.combineRun === true && atoms[first - 1]?.runIndex === left.runIndex) first -= 1;
+		while (last + 1 < atoms.length && right?.combineRun === true && atoms[last + 1]?.runIndex === right.runIndex) last += 1;
+		return {
+			start: first,
+			end: last + 1
+		};
+	};
+	for (const association of rubyAssociations) {
+		const { indexes } = association;
+		if ((association.reading.kind === "group" ? [association.reading.text] : association.reading.segments).some((text) => measurements.pieces(text, "ruby") === void 0)) return void 0;
+		if (association.reading.kind === "group") {
+			const pieces = measurements.pieces(association.reading.text, "ruby");
+			if (pieces === void 0) return void 0;
+			const group = GroupRubyAllocation.prepare(association, pieces, baseAdvances);
+			if (group === void 0) return void 0;
+			groupReadings.push(group);
+			continue;
+		}
+		for (const [segmentIndex, index] of indexes.entries()) {
+			const segment = association.reading.segments[segmentIndex];
+			const atom = atoms[index];
+			if (segment === void 0 || atom === void 0) continue;
+			const pieces = measurements.pieces(segment, "ruby");
+			if (pieces === void 0) return void 0;
+			candidateReadings.push({
+				association,
+				...physicalRange(index, index),
+				pieces
+			});
+		}
+	}
+	const sourceSpaces = SourceSpace.collect(sourceLine, atoms.map(({ boxAdvanceEm }) => boxAdvanceEm));
+	return {
+		atoms,
+		runs,
+		rubyAssociations,
+		candidateReadings,
+		groupReadings,
+		sourceSpaces,
+		suppressedIndexes: new Set(sourceSpaces.filter((space) => space.edgeBehavior === "suppress").map((space) => space.index))
+	};
+}
+function continuationFor(annotation, range) {
+	const starts = range.graphemes.start === annotation.range.graphemes.start;
+	const ends = range.graphemes.end === annotation.range.graphemes.end;
+	if (starts && ends) return "whole";
+	if (starts) return "start";
+	if (ends) return "end";
+	return "middle";
+}
+function annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation) {
+	return ManuscriptRange.merge([
+		...graphemes.flatMap((unit) => unit.sources.flatMap(SourcePlacement.ranges)).filter((range) => ManuscriptRange.overlaps(range, annotation.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, sourceGlues, annotations, candidatePlacements, emphasisForUnit) {
+	const fragments = [];
+	for (const annotation of annotations) {
+		const covered = graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range));
+		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;
+		const common = {
+			annotationRange: annotation.range,
+			fragmentRange,
+			continuation: continuationFor(annotation, fragmentRange)
+		};
+		switch (annotation.kind) {
+			case "bold":
+			case "italic":
+				fragments.push({
+					kind: annotation.kind,
+					...common
+				});
+				break;
+			case "emphasis":
+				fragments.push({
+					kind: "emphasis",
+					mark: annotation.mark,
+					placements: covered.flatMap((unit) => {
+						const mark = emphasisForUnit(unit);
+						return mark?.annotation === annotation ? [mark.placement] : [];
+					}),
+					...common
+				});
+				break;
+			case "ruby": {
+				const resolved = candidatePlacements.filter(({ segment }) => segment.association.baseRange === annotation.range);
+				if (resolved.length > 0) {
+					let textOffset = 0;
+					const readingItems = resolved.flatMap(({ items }) => {
+						const mapped = items.map((item) => ({
+							...item,
+							textRange: MeasurementTextRange.of({
+								start: textOffset + item.textRange.start,
+								end: textOffset + item.textRange.end
+							})
+						}));
+						textOffset += items.at(-1)?.textRange.end ?? 0;
+						return mapped;
+					});
+					fragments.push({
+						kind: "ruby",
+						rubyKind: annotation.reading.kind,
+						reading: readingItems.map(({ value }) => value).join(""),
+						readingItems,
+						...common
+					});
+					break;
+				}
+				return;
+			}
+		}
+	}
+	for (const unit of graphemes.filter((glyph) => glyph.kind === "combined-glyph")) {
+		const readings = fragments.filter((fragment) => fragment.kind === "ruby" && ManuscriptRange.overlaps(fragment.fragmentRange, unit.range));
+		for (const [index, left] of readings.entries()) {
+			if (left.kind !== "ruby") continue;
+			if (readings.slice(index + 1).some((right) => right.kind === "ruby" && left.readingItems.some(({ placement: a }) => right.readingItems.some(({ placement: b }) => a.inlineSpan.offsetEm < b.inlineSpan.offsetEm + b.inlineSpan.advanceEm - 1e-9 && b.inlineSpan.offsetEm < a.inlineSpan.offsetEm + a.inlineSpan.advanceEm - 1e-9 && a.blockOffsetEm < b.blockOffsetEm + b.blockSizeEm && b.blockOffsetEm < a.blockOffsetEm + a.blockSizeEm)))) return void 0;
+		}
+	}
+	return fragments;
+}
+function renderUnits(raw) {
+	const items = [];
+	for (let index = 0; index < raw.length; index += 1) {
+		const first = raw[index];
+		if (first === void 0) continue;
+		if (first.kind !== "member") {
+			items.push(first);
+			continue;
+		}
+		const members = [first];
+		if (first.atom.combineRun) while (index + 1 < raw.length) {
+			const next = raw[index + 1];
+			if (next?.kind !== "member" || next.atom.runIndex !== first.atom.runIndex) break;
+			members.push(next);
+			index += 1;
+		}
+		const last = members.at(-1);
+		if (last === void 0) return void 0;
+		const range = ManuscriptRange.merge(members.map(({ atom }) => atom.grapheme.range));
+		if (range === null) return void 0;
+		const sources = [];
+		for (let memberIndex = 0; memberIndex < members.length; memberIndex += 1) {
+			const member = members[memberIndex];
+			if (member === void 0) return void 0;
+			const cluster = member.atom.clusterRange;
+			if (cluster === null) {
+				sources.push({
+					kind: "exact",
+					range: member.atom.grapheme.range,
+					layoutSpan: member.layoutSpan
+				});
+				continue;
+			}
+			const shared = members.slice(memberIndex, memberIndex + cluster.graphemes.end - cluster.graphemes.start);
+			if (shared.some(({ atom }) => atom.clusterRange === null || atom.clusterRange.graphemes.start !== cluster.graphemes.start || atom.clusterRange.graphemes.end !== cluster.graphemes.end)) return void 0;
+			const end = shared.at(-1);
+			if (end === void 0 || shared.length !== cluster.graphemes.end - cluster.graphemes.start) return void 0;
+			sources.push({
+				kind: "shared",
+				ranges: shared.map(({ atom }) => atom.grapheme.range),
+				layoutSpan: {
+					offsetEm: member.layoutSpan.offsetEm,
+					advanceEm: end.layoutSpan.offsetEm + end.layoutSpan.advanceEm - member.layoutSpan.offsetEm
+				}
+			});
+			memberIndex += shared.length - 1;
+		}
+		let renderStart = Number.POSITIVE_INFINITY;
+		let renderEnd = Number.NEGATIVE_INFINITY;
+		for (const { atom, renderSpan } of members) {
+			if (atom.clusterRange !== null && atom.grapheme.range.graphemes.start !== atom.clusterRange.graphemes.start) continue;
+			renderStart = Math.min(renderStart, renderSpan.offsetEm);
+			renderEnd = Math.max(renderEnd, renderSpan.offsetEm + renderSpan.advanceEm);
+		}
+		const common = {
+			value: members.map(({ atom }) => atom.grapheme.value).join(""),
+			range,
+			sources,
+			layoutSpan: {
+				offsetEm: first.layoutSpan.offsetEm,
+				advanceEm: last.layoutSpan.offsetEm + last.layoutSpan.advanceEm - first.layoutSpan.offsetEm
+			},
+			renderSpan: {
+				offsetEm: renderStart,
+				advanceEm: renderEnd - renderStart
+			}
+		};
+		const presentation = first.atom.presentation;
+		if (first.atom.combineRun) {
+			if (members.length < 2 || presentation !== "tate-chu-yoko" && presentation !== "sideways") return void 0;
+			items.push({
+				...common,
+				kind: "combined-glyph",
+				presentation,
+				disposition: "placed"
+			});
+		} else {
+			if (presentation === "tate-chu-yoko") return void 0;
+			items.push({
+				...common,
+				kind: "glyph",
+				presentation,
+				disposition: first.disposition
+			});
+		}
+	}
+	return items;
+}
+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]));
+	const characterSpacings = new Map(plan.characterSpacings.map((spacing) => [spacing.index, spacing]));
+	const boxAdjustments = new Map(plan.boxAdjustments?.map((box) => [box.index, box]));
+	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",
+			offsetEm,
+			widthEm: spacing.widthEm
+		});
+		else items.push({
+			kind: "glue",
+			origin: "generated",
+			offsetEm,
+			widthEm: spacing.widthEm,
+			naturalWidthEm: spacing.naturalWidthEm,
+			adjustment: adjustmentOf(spacing.widthEm, spacing.naturalWidthEm)
+		});
+		offsetEm += spacing.widthEm;
+	};
+	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;
+		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,
+				naturalWidthEm,
+				adjustment: adjustmentOf(widthEm, naturalWidthEm)
+			});
+			offsetEm += widthEm;
+			continue;
+		}
+		const hanging = plan.hangingIndex === index;
+		const adjusted = boxAdjustments.get(index);
+		const layoutAdvanceEm = hanging ? 0 : adjusted?.advanceEm ?? atom.boxAdvanceEm;
+		items.push({
+			kind: "member",
+			atom,
+			layoutSpan: {
+				offsetEm,
+				advanceEm: layoutAdvanceEm
+			},
+			renderSpan: {
+				offsetEm: offsetEm + (adjusted?.renderOffsetEm ?? atom.renderOffsetEm),
+				advanceEm: atom.renderAdvanceEm
+			},
+			disposition: hanging ? "hanging" : "placed"
+		});
+		offsetEm += layoutAdvanceEm;
+	}
+	const trailingSpacing = spacings.get(plan.end);
+	if (trailingSpacing !== void 0) positionSpacing(trailingSpacing);
+	const positioned = renderUnits(items);
+	if (positioned === void 0) return void 0;
+	const ranges = positioned.flatMap((item) => PositionedInlineItem.isRenderUnit(item) || item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
+	return {
+		range: ManuscriptRange.merge(ranges),
+		inlineSizeEm: Math.max(0, plan.inlineSizeEm),
+		items: positioned,
+		break: plan.break,
+		annotations: []
+	};
+}
+function wrapSourceLine(sourceLine, annotations, settings) {
+	if (sourceLine.atoms.length === 0) return ManuscriptResult.succeed([NovelLine.empty()]);
+	const profile = TYPESETTING_PROFILE;
+	const characters = sourceLine.atoms.map((atom, index) => ({
+		boxAdvanceEm: atom.boxAdvanceEm,
+		sourceGap: sourceLine.suppressedIndexes.has(index),
+		characterClass: atom.characterClass
+	}));
+	const rubyInteriors = RubyAssociation.fittableInteriors(sourceLine.rubyAssociations, characters.map(({ boxAdvanceEm }) => boxAdvanceEm), settings.flow.lineLengthEm, new Set(sourceLine.groupReadings.filter((group) => Math.max(group.basePrefixEm.at(-1) ?? 0, group.pieces.reduce((sum, piece) => sum + piece.layoutSpan.advanceEm, 0)) <= settings.flow.lineLengthEm).map((group) => group.association)));
+	const rubyByIndex = new Map(sourceLine.rubyAssociations.flatMap((association) => association.indexes.map((index) => [index, association])));
+	const rubyBases = sourceLine.atoms.map((atom, index) => {
+		const association = rubyByIndex.get(index);
+		return {
+			lexicalClass: atom.characterClass,
+			effectiveClass: association === void 0 ? atom.characterClass : association.reading.kind === "jukugo" ? "cl-23" : "cl-22",
+			advanceEm: atom.boxAdvanceEm,
+			renderOffsetEm: atom.renderOffsetEm,
+			sourceGap: sourceLine.suppressedIndexes.has(index)
+		};
+	});
+	const resolveBoundary = (leftIndex, rightIndex) => {
+		const left = sourceLine.atoms[leftIndex];
+		const right = sourceLine.atoms[rightIndex];
+		const leftBase = rubyBases[leftIndex];
+		const rightBase = rubyBases[rightIndex];
+		if (left === void 0 || right === void 0 || leftBase === void 0 || rightBase === void 0) return void 0;
+		const compound = rubyByIndex.get(leftIndex);
+		const rubySpacingInterior = compound !== void 0 && compound === rubyByIndex.get(rightIndex) && compound.reading.kind !== "mono";
+		return BoundaryRule.resolve(leftBase.effectiveClass, rightBase.effectiveClass, profile, {
+			bindingSequence: leftBase.effectiveClass === "cl-08" && rightBase.effectiveClass === "cl-08" && BindingSequence.contains(left.grapheme.value, right.grapheme.value),
+			runInterior: left.runIndex === right.runIndex,
+			rubyInterior: rubyInteriors.has(rightIndex),
+			rubySpacingInterior,
+			sourceGap: sourceLine.suppressedIndexes.has(leftIndex) || sourceLine.suppressedIndexes.has(rightIndex)
+		});
+	};
+	const boundaries = Array.from({ length: characters.length + 1 }, (_, boundary) => resolveBoundary(boundary - 1, boundary));
+	const nextVisible = Array.from({ length: characters.length + 1 }).fill(characters.length);
+	for (let index = characters.length - 1; index >= 0; index -= 1) nextVisible[index] = characters[index]?.sourceGap === true ? nextVisible[index + 1] ?? characters.length : index;
+	const acrossGaps = characters.map((_, left) => resolveBoundary(left, nextVisible[left + 1] ?? characters.length));
+	const paragraph = JapaneseParagraph.of(rubyBases.map((base) => ({
+		boxAdvanceEm: base.advanceEm,
+		characterClass: base.lexicalClass,
+		effectiveClass: base.effectiveClass,
+		sourceGap: base.sourceGap
+	})), boundaries, profile, settings.flow.lineLengthEm);
+	const readingIndex = RubyLineLayout.index(sourceLine.candidateReadings);
+	const groupByIndex = new Map(sourceLine.groupReadings.flatMap((group) => group.association.indexes.map((index) => [index, group])));
+	const resolvedRuby = /* @__PURE__ */ new WeakMap();
+	const emphasisBySource = /* @__PURE__ */ new Map();
+	const globalStart = sourceLine.atoms[0]?.grapheme.range.graphemes.start ?? 0;
+	for (const [order, annotation] of annotations.entries()) {
+		if (annotation.kind !== "emphasis") continue;
+		const start = Math.max(annotation.range.graphemes.start, globalStart);
+		const end = Math.min(annotation.range.graphemes.end, globalStart + characters.length);
+		for (let index = start; index < end; index += 1) if (!emphasisBySource.has(index)) emphasisBySource.set(index, {
+			annotation,
+			order
+		});
+	}
+	const emphasisForUnit = (unit) => {
+		if (!EmphasisPlacement.accepts(sourceLine.atoms[unit.range.graphemes.start - globalStart]?.characterClass)) return void 0;
+		let selected;
+		for (let index = unit.range.graphemes.start; index < unit.range.graphemes.end; index += 1) {
+			const candidate = emphasisBySource.get(index);
+			if (candidate !== void 0 && (selected === void 0 || candidate.order < selected.order)) selected = candidate;
+		}
+		return selected === void 0 ? void 0 : {
+			annotation: selected.annotation,
+			placement: EmphasisPlacement.of(unit.renderSpan)
+		};
+	};
+	let refusalReason = "render units or reading clusters cannot be placed without splitting or collision";
+	const plans = layoutParagraph(paragraph.elements, settings.flow.lineLengthEm, (start, end, cursor) => {
+		if (sourceLine.candidateReadings.length === 0 && sourceLine.groupReadings.length === 0 && emphasisBySource.size === 0) return paragraph.resolveCandidate(start, end);
+		const effectiveEnd = nextVisible[end] === characters.length ? characters.length : end;
+		const groups = /* @__PURE__ */ new Set();
+		for (let index = start; index < effectiveEnd; index += 1) {
+			const group = groupByIndex.get(index);
+			if (group !== void 0) groups.add(group);
+		}
+		const assigned = [];
+		let nextCursor = cursor;
+		for (const group of groups) {
+			const allocation = GroupRubyAllocation.assign(group, start, effectiveEnd, nextCursor, settings.flow.lineLengthEm);
+			const physical = allocation.segment;
+			const first = sourceLine.atoms[Math.max(physical.start, nextVisible[start] ?? start)];
+			const last = sourceLine.atoms[Math.min(physical.end, end) - 1];
+			if (first === void 0 || last === void 0) return void 0;
+			const firstRun = first.combineRun ? sourceLine.runs[first.runIndex] : void 0;
+			const lastRun = last.combineRun ? sourceLine.runs[last.runIndex] : void 0;
+			const globalStart = sourceLine.atoms[0]?.grapheme.range.graphemes.start ?? 0;
+			assigned.push({
+				...physical,
+				start: firstRun === void 0 ? Math.max(physical.start, nextVisible[start] ?? start) : firstRun.range.graphemes.start - globalStart,
+				end: lastRun === void 0 ? Math.min(physical.end, end) : lastRun.range.graphemes.end - globalStart
+			});
+			nextCursor = allocation.nextCursor;
+		}
+		const result = RubyLineLayout.resolve(rubyBases, readingIndex, start, end, (metrics) => paragraph.resolveCandidate(start, end, metrics), assigned);
+		if (result === void 0) return void 0;
+		const areas = result.placements.map((reading) => reading.items.map((item) => item.placement));
+		if (emphasisBySource.size > 0) {
+			const positioned = positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, result.line);
+			if (positioned === void 0) return void 0;
+			for (const unit of positioned.items.filter(PositionedInlineItem.isRenderUnit)) {
+				const mark = emphasisForUnit(unit);
+				if (mark !== void 0 && mark.annotation.mark !== "") areas.push([mark.placement]);
+			}
+		}
+		const clearance = AnnotationClearance.resolve(areas);
+		if (clearance.kind === "refused") {
+			refusalReason = clearance.reason;
+			return;
+		}
+		if (result.line.boxAdjustments !== void 0) resolvedRuby.set(result.line.boxAdjustments, result.placements);
+		return {
+			...result.line,
+			nextCursor
+		};
+	}, (left, right) => (right === left + 1 ? boundaries[right] : acrossGaps[left])?.break.kind !== "prohibited");
+	if (plans.length === 0) return ManuscriptResult.fail({ reason: refusalReason });
+	const lines = [];
+	for (const plan of plans) {
+		const line = positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, plan);
+		if (line === void 0) return ManuscriptResult.fail({ reason: "render units cannot preserve their source members" });
+		lines.push(line);
+	}
+	const annotated = [];
+	for (const [index, line] of lines.entries()) {
+		const plan = plans[index];
+		const fragments = annotationFragments(line.items.filter(PositionedInlineItem.isRenderUnit), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotations, plan?.boxAdjustments === void 0 ? [] : resolvedRuby.get(plan.boxAdjustments) ?? [], emphasisForUnit);
+		if (fragments === void 0) return ManuscriptResult.fail({ reason: "annotation fragments cannot preserve their reading positions" });
+		annotated.push({
+			...line,
+			annotations: fragments
+		});
+	}
+	return ManuscriptResult.succeed(annotated);
+}
+function blankLines(count) {
+	return Array.from({ length: count }, NovelLine.empty);
+}
+function buildPages(contentLines, settings) {
+	const { linesPerStage, stagesPerPage } = settings.flow;
+	const { stage: stageOffset, page: pageOffset } = settings.offsets;
+	const usablePerStage = linesPerStage - LineOffset.total(stageOffset);
+	const usablePerPage = usablePerStage * stagesPerPage;
+	const pages = [];
+	let contentIndex = 0;
+	while (contentIndex < contentLines.length || pages.length === 0) {
+		const stages = [];
+		for (let stageIndex = 0; stageIndex < stagesPerPage; stageIndex += 1) {
+			const lines = [];
+			for (let position = 0; position < linesPerStage; position += 1) {
+				const usableIndex = stageIndex * usablePerStage + position - stageOffset.leading;
+				const withinStage = position >= stageOffset.leading && position < linesPerStage - stageOffset.trailing;
+				const withinPage = usableIndex >= pageOffset.leading && usableIndex < usablePerPage - pageOffset.trailing;
+				const next = contentLines[contentIndex];
+				if (!withinStage || !withinPage || next === void 0) {
+					lines.push(NovelLine.empty());
+					continue;
+				}
+				lines.push(next);
+				contentIndex += 1;
+			}
+			stages.push(NovelStage.of(lines));
+		}
+		pages.push(NovelPage.of(stages));
+	}
+	return pages;
+}
+function createCompose(provider) {
+	return (manuscript, settings) => {
+		const measurements = MeasurementSession.create(provider, settings);
+		const sourceLines = displayedLines(manuscript.graphemes);
+		const measured = sourceLines.map((line) => measureSourceLine(line, manuscript.annotations, measurements));
+		if (measured.some((line) => line === void 0)) return ManuscriptResult.fail({ reason: "run measurer returned invalid metrics or cluster mappings" });
+		const manuscriptLines = [];
+		for (const line of measured) {
+			if (line === void 0) continue;
+			const wrapped = wrapSourceLine(line, manuscript.annotations, settings);
+			if (!wrapped.ok) return ManuscriptResult.fail(wrapped.error);
+			manuscriptLines.push(...wrapped.value);
+		}
+		if (!NovelSourceContract.matches(manuscript, manuscriptLines)) return ManuscriptResult.fail({ reason: "composition did not preserve source members or ruby readings" });
+		const pages = buildPages([
+			...blankLines(settings.offsets.document.leading),
+			...manuscriptLines,
+			...blankLines(settings.offsets.document.trailing)
+		], settings);
+		return ManuscriptResult.succeed({
+			pages,
+			geometry: ManuscriptGeometry.of(settings.flow, settings.appearance),
+			stats: {
+				chars: sourceLines.reduce((total, line) => total + line.length, 0),
+				sourceLines: sourceLines.length,
+				pages: pages.length
+			}
+		});
+	};
+}
+function createNovelComposer(options) {
+	return {
+		id: COMPOSER_ID,
+		settingsSchema: NovelCompositionSettings.schema,
+		layoutSchema: NovelLayout.schema,
+		compose: createCompose(options.measurer)
+	};
+}
+const novelComposer = createNovelComposer({ measurer: logicalRunMeasurer });
+//#endregion
+export { PaperSize as a, MeasurementTextRange as c, ManuscriptOffsets as d, ManuscriptAppearanceSettings as f, ParsedManuscript as g, FontPresetId as h, ManuscriptGeometry as i, NovelCompositionSettings as l, FontSizePt as m, novelComposer as n, RunMeasurement as o, PaperSizeId as p, logicalRunMeasurer as r, MeasuredCluster as s, createNovelComposer as t, NovelFlowSettings as u };