@sushichan044/kg-core 0.6.5 → 0.8.0

package/dist/novel-composer-CROZLBqt.mjs

@@ -0,0 +1,1929 @@
+import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, i as OPENING_BRACKETS, m as readonlyArray, o as graphemeSegmenter, p as nonNegativeInteger, r as CLOSING_BRACKETS, t as questionOrExclamationSpacings } from "./question-or-exclamation-spacing-B5o23ZLf.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)
+};
+const InlineMeasurement = { schema: readonlyObject({ advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)) }) };
+function graphemeWidth(grapheme) {
+	let width = 1;
+	for (const character of grapheme) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0) width = Math.max(width, eastAsianWidth(codePoint, { ambiguousAsWide: true }));
+	}
+	return width / 2;
+}
+/**
+* Deterministic Japanese-context measurement in logical em units.
+*/
+const logicalInlineMeasurer = (request) => {
+	const { text } = request;
+	const width = [...graphemeSegmenter.segment(text)].reduce((total, { segment }) => total + graphemeWidth(segment), 0);
+	if (request.role === "ruby") return { advanceEm: width / 2 };
+	return { advanceEm: request.presentation === "upright" ? [...graphemeSegmenter.segment(text)].length : width };
+};
+//#endregion
+//#region src/composer/internal/japanese-typesetting-profile.ts
+/**
+* The JLReq character classes (文字クラス) this profile distinguishes. 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 OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
+const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
+const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
+const DIVIDING_PUNCTUATION = /* @__PURE__ */ new Set("！？‼⁇⁈⁉");
+const MIDDLE_DOTS = /* @__PURE__ */ new Set("・：；");
+const SMALL_KANA = /* @__PURE__ */ new Set("ァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ");
+const ITERATION_MARKS = /* @__PURE__ */ new Set("ヽヾゝゞ々〻");
+const INSEPARABLE = /* @__PURE__ */ new Set("—―…‥─〳〵");
+const PREFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("￥＄£#＃");
+const POSTFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("°′″％‰");
+const UNIT_SYMBOLS = /* @__PURE__ */ new Set("℃℉㎀㎁㎂㎃㎄㎅㎆㎇㎈㎉㎊㎋㎌㎍㎎㎏㎐㎑㎒㎓㎔㎕㎖㎗㎘㎙㎚㎛㎜㎝㎞㎟㎠㎡㎢");
+const GROUPED_NUMERAL = /^[0-9０-９]$/u;
+const HIRAGANA = /^\p{Script=Hiragana}$/u;
+const KATAKANA = /^\p{Script=Katakana}$/u;
+const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
+/**
+* Order matters: a character inside a tate-chu-yoko group is cl-30 whatever it would be on its own,
+* and anything left unmatched is cl-19, the class JLReq reserves for kanji and the like.
+*/
+function classify({ value, presentation }) {
+	if (presentation === "tate-chu-yoko") return "cl-30";
+	if (OPENING.has(value)) return "cl-01";
+	if (CLOSING.has(value)) return "cl-02";
+	if (HYPHENS.has(value)) return "cl-03";
+	if (DIVIDING_PUNCTUATION.has(value)) return "cl-04";
+	if (MIDDLE_DOTS.has(value)) return "cl-05";
+	if (value === "。" || value === "．") return "cl-06";
+	if (value === "、" || value === "，") return "cl-07";
+	if (INSEPARABLE.has(value)) return "cl-08";
+	if (ITERATION_MARKS.has(value)) return "cl-09";
+	if (value === "ー") return "cl-10";
+	if (SMALL_KANA.has(value)) return "cl-11";
+	if (PREFIXED_ABBREVIATIONS.has(value)) return "cl-12";
+	if (POSTFIXED_ABBREVIATIONS.has(value)) return "cl-13";
+	if (value === "　") return "cl-14";
+	if (HIRAGANA.test(value)) return "cl-15";
+	if (KATAKANA.test(value)) return "cl-16";
+	if (GROUPED_NUMERAL.test(value)) return "cl-24";
+	if (UNIT_SYMBOLS.has(value)) return "cl-25";
+	if (value === " ") return "cl-26";
+	if (WESTERN.test(value)) return "cl-27";
+	return "cl-19";
+}
+/**
+* The stages JLReq 3.8.3 spends inter-character space in, as glue priorities: the lower the number,
+* the earlier the paragraph optimizer takes it.
+*
+* JLReq's own first stage is the western word space (cl-26), which is absent here because reducing
+* it means resizing the space's own advance rather than a space between two characters.
+*
+* The line-end stage is priority 0, which the optimizer also charges nothing for. JLReq 3.1.9 is
+* what allows that: the half em after a closing bracket, full stop or comma — and the quarter em
+* after a middle dot — cannot be seen once that character sits at the line end. JLReq orders it
+* second rather than first, but only after the word space this profile does not adjust at all.
+* Stages two and three are one priority here because a line has a single line end, so the two never
+* compete.
+*/
+const REDUCTION_STAGE = {
+	/**
+	* Stages 2 and 3: the space after a closing bracket, full stop, comma or middle dot at line end.
+	*/
+	lineEnd: 0,
+	/**
+	* Stage 4: the quarter em on either side of a mid-line middle dot.
+	*/
+	middleDot: 1,
+	/**
+	* Stage 5: the half em before an opening bracket and after a closing bracket or comma.
+	*/
+	punctuation: 2,
+	/**
+	* Stage 6: the quarter em between Japanese and a numeral, unit symbol or western character.
+	*/
+	mixedText: 3
+};
+/**
+* The stages JLReq 3.8.4 adds inter-character space in, as glue priorities on the same reading as
+* {@link REDUCTION_STAGE}: the lower the number, the earlier the paragraph optimizer takes it. A
+* line is either reduced or expanded, never both, so the two scales never meet.
+*
+* Stage 1 is the western word space (cl-26), absent for the same reason it is absent from the
+* reduction stages. Stage 4 spreads whatever a、b and c could not absorb across every character gap
+* that is not unbreakable, and is deliberately not implemented: it would justify every line that
+* currently falls short, which reads as prose combed out to the margin rather than a novel.
+*/
+const EXPANSION_STAGE = {
+	/**
+	* Stage 2: the quarter em between Japanese and a numeral, unit symbol or western character.
+	*/
+	mixedText: 1,
+	/**
+	* Stage 3: everywhere else 表6 admits, from solid up to a quarter em.
+	*/
+	solid: 2
+};
+/**
+* 無印 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: {
+		priority: EXPANSION_STAGE.solid,
+		amountEm: .25
+	}
+};
+/**
+* `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: {
+		priority: REDUCTION_STAGE.punctuation,
+		amountEm: .5
+	}
+};
+/**
+* `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: {
+		priority: REDUCTION_STAGE.middleDot,
+		amountEm: .25
+	}
+};
+/**
+* `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.
+*/
+const MIXED_TEXT_QUARTER = {
+	kind: "glue",
+	naturalWidthEm: .25,
+	shrink: {
+		priority: REDUCTION_STAGE.mixedText,
+		amountEm: .125
+	},
+	stretch: {
+		priority: EXPANSION_STAGE.mixedText,
+		amountEm: .25
+	}
+};
+/**
+* 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: {
+		priority: REDUCTION_STAGE.mixedText,
+		amountEm: .125
+	}
+};
+/**
+* 表1 注3 with 表3 注1: two middle dots meet, and their quarters go solid together.
+*/
+const TWO_QUARTERS = {
+	kind: "glue",
+	naturalWidthEm: .5,
+	shrink: {
+		priority: REDUCTION_STAGE.middleDot,
+		amountEm: .5
+	}
+};
+/**
+* 表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: {
+		priority: REDUCTION_STAGE.middleDot,
+		amountEm: .25
+	}
+};
+/**
+* 表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: {
+		priority: REDUCTION_STAGE.punctuation,
+		amountEm: .75
+	}
+};
+/**
+* 分離禁止文字 repeated (a 2倍ダッシュ, a 2倍リーダ) must read as one continuous rule (3.1.10).
+*/
+const DASH_JOINT = {
+	kind: "kern",
+	naturalWidthEm: 0
+};
+/**
+* The classes that take a quarter em against a numeral, unit symbol or western character (3.2.6).
+* Dividing punctuation is on the list in that direction only, because the space before a `？` or `！`
+* is solid (3.1.6).
+*/
+const JAPANESE_BEFORE_WESTERN = [
+	"cl-04",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30"
+];
+const JAPANESE_AFTER_WESTERN = [
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30"
+];
+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"
+];
+const EXPANDABLE_AFTER = [
+	"cl-08",
+	"cl-09",
+	"cl-10",
+	"cl-11",
+	"cl-12",
+	"cl-13",
+	"cl-15",
+	"cl-16",
+	"cl-19",
+	"cl-30"
+];
+/**
+* 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: DASH_JOINT
+	}
+].flatMap(({ left, right, spacing }) => (left === "any" ? japaneseCharacterClasses : left).flatMap((leftClass) => (right === "any" ? japaneseCharacterClasses : 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.
+*
+* Unbreakable sequences (分割禁止, JLReq 3.1.10): a 分離禁止文字 followed by another one is a single mark set
+* over two ems and must not be split.
+*/
+function breakPenalty(left, right) {
+	if (left === "cl-01" || left === "cl-12") return null;
+	if (right === "cl-02" || right === "cl-03" || right === "cl-04" || right === "cl-05" || right === "cl-06" || right === "cl-07" || right === "cl-09" || right === "cl-10" || right === "cl-11" || right === "cl-13") return null;
+	if (left === "cl-08" && right === "cl-08") return null;
+	return 0;
+}
+const defaultJapaneseTypesettingProfile = {
+	classify,
+	/**
+	* 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) => {
+		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,
+	/**
+	* An opening bracket at the line head keeps a half em of white, so a line of dialogue starts one
+	* half em in rather than tight against the edge. JLReq 3.1.5 lists three schemes for that white
+	* and 表1 注17 sets solid as the principle; the half em is the variant the publishers of Japanese
+	* novels use for a line that begins a paragraph.
+	*
+	* The white is not shrinkable. 表3 excludes the line head from line adjustment altogether, and
+	* shrinking it is exactly what pushed a line-head bracket flush against the edge in #94.
+	*/
+	lineStartSpacing: (first) => first === "cl-01" ? {
+		kind: "glue",
+		naturalWidthEm: .5
+	} : null,
+	/**
+	* The half em trailing a closing bracket, full stop or comma at the line end, and the quarter em
+	* trailing a middle dot there (JLReq 3.1.9). Priority 0: spending it changes nothing the reader
+	* can see.
+	*/
+	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
+		kind: "glue",
+		naturalWidthEm: .5,
+		shrink: {
+			priority: REDUCTION_STAGE.lineEnd,
+			amountEm: .5
+		}
+	} : last === "cl-05" ? {
+		kind: "glue",
+		naturalWidthEm: .25,
+		shrink: {
+			priority: REDUCTION_STAGE.lineEnd,
+			amountEm: .25
+		}
+	} : null,
+	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"
+};
+//#endregion
+//#region src/composer/internal/paragraph-layout.ts
+const EPSILON = 1e-9;
+/**
+* Spending capacity at this priority changes nothing the reader can see.
+*/
+const FREE_SHRINK_PRIORITY = 0;
+function skipSourceGaps(atoms, start) {
+	let cursor = start;
+	while (atoms[cursor]?.sourceGap === true) cursor += 1;
+	return cursor;
+}
+function previousVisible(atoms, end) {
+	for (let index = end - 1; index >= 0; index -= 1) if (atoms[index]?.sourceGap === false) return index;
+}
+function opportunities(atoms, classes, start, end, profile) {
+	const result = [];
+	const firstClass = classes[start];
+	const startSpacing = firstClass === void 0 ? null : profile.lineStartSpacing(firstClass);
+	if (startSpacing !== null) result.push({
+		boundary: start,
+		spacing: startSpacing
+	});
+	for (let right = start + 1; right < end; right += 1) {
+		const leftAtom = atoms[right - 1];
+		const rightAtom = atoms[right];
+		const leftClass = classes[right - 1];
+		const rightClass = classes[right];
+		if (leftAtom === void 0 || rightAtom === void 0 || leftClass === void 0 || rightClass === void 0 || leftAtom.sourceGap || rightAtom.sourceGap || !leftAtom.pairSpacingAfter) continue;
+		result.push({
+			boundary: right,
+			spacing: profile.pairSpacing(leftClass, rightClass)
+		});
+	}
+	const lastClass = classes[end - 1];
+	const endSpacing = lastClass === void 0 ? null : profile.lineEndSpacing(lastClass);
+	if (endSpacing !== null) result.push({
+		boundary: end,
+		spacing: endSpacing
+	});
+	return result;
+}
+function capacity(values, select) {
+	return values.reduce((total, opportunity) => total + (select(opportunity.spacing)?.amountEm ?? 0), 0);
+}
+function resolveSpacings(values, adjustment, amountEm) {
+	const remainingByBoundary = /* @__PURE__ */ new Map();
+	let remaining = amountEm;
+	let priorityCost = 0;
+	const capacities = values.flatMap((opportunity) => {
+		const selected = adjustment === "shrink" ? opportunity.spacing.shrink : opportunity.spacing.stretch;
+		return selected === void 0 ? [] : [{
+			...opportunity,
+			capacity: selected
+		}];
+	}).sort((left, right) => left.capacity.priority - right.capacity.priority || left.boundary - right.boundary);
+	for (const opportunity of capacities) {
+		if (remaining <= EPSILON) break;
+		const used = Math.min(remaining, opportunity.capacity.amountEm);
+		remainingByBoundary.set(opportunity.boundary, used);
+		priorityCost += used * opportunity.capacity.priority;
+		remaining -= used;
+	}
+	return {
+		spacings: values.map(({ boundary, spacing }) => {
+			const used = remainingByBoundary.get(boundary) ?? 0;
+			return {
+				boundary,
+				kind: spacing.kind,
+				naturalWidthEm: spacing.naturalWidthEm,
+				widthEm: adjustment === "shrink" ? spacing.naturalWidthEm - used : spacing.naturalWidthEm + used
+			};
+		}),
+		priorityCost
+	};
+}
+function candidate(atoms, classes, start, end, lineLengthEm, profile) {
+	const contentStart = skipSourceGaps(atoms, start);
+	const suppressedIndexes = Array.from({ length: contentStart - start }, (_, index) => start + index);
+	const pairValues = opportunities(atoms, classes, contentStart, end, profile);
+	const naturalSizeEm = atoms.slice(contentStart, end).reduce((total, atom) => total + atom.boxAdvanceEm, 0) + pairValues.reduce((total, value) => total + value.spacing.naturalWidthEm, 0);
+	const terminal = skipSourceGaps(atoms, end) === atoms.length;
+	const shrinkCapacity = capacity(pairValues, ({ shrink }) => shrink);
+	const freeShrinkCapacity = capacity(pairValues, ({ shrink }) => shrink?.priority === FREE_SHRINK_PRIORITY ? shrink : void 0);
+	const stretchCapacity = capacity(pairValues, ({ stretch }) => stretch);
+	const overflow = naturalSizeEm - lineLengthEm;
+	const underflow = lineLengthEm - naturalSizeEm;
+	const lastVisible = previousVisible(atoms, end);
+	const lastClass = lastVisible === void 0 ? void 0 : classes[lastVisible];
+	const lastAdvance = lastVisible === void 0 ? 0 : atoms[lastVisible]?.boxAdvanceEm ?? 0;
+	const trailingSpacing = pairValues.find(({ boundary }) => boundary === end)?.spacing.naturalWidthEm ?? 0;
+	if (terminal && overflow <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "paragraph-end" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		priorityCost: 0
+	};
+	if (Math.abs(overflow) <= EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "natural" },
+		hangingIndex: null,
+		deformationRatio: 0,
+		priorityCost: 0
+	};
+	if (overflow > 0 && overflow <= shrinkCapacity + EPSILON) {
+		const resolved = resolveSpacings(pairValues, "shrink", overflow);
+		const chargeableCapacity = shrinkCapacity - freeShrinkCapacity;
+		const chargeableShrink = Math.max(0, overflow - freeShrinkCapacity);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			pairSpacings: resolved.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "shrunk" },
+			hangingIndex: null,
+			deformationRatio: chargeableCapacity <= EPSILON ? 0 : chargeableShrink / chargeableCapacity,
+			priorityCost: resolved.priorityCost
+		};
+	}
+	if (!terminal && overflow > 0 && lastVisible !== void 0 && lastClass !== void 0 && profile.canHang(lastClass) && naturalSizeEm - lastAdvance - trailingSpacing <= lineLengthEm + EPSILON) return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings.filter(({ boundary }) => boundary !== end),
+		inlineSizeEm: naturalSizeEm - lastAdvance - trailingSpacing,
+		break: { kind: "hanging" },
+		hangingIndex: lastVisible,
+		deformationRatio: overflow / Math.max(lastAdvance, EPSILON),
+		priorityCost: 0
+	};
+	if (!terminal && underflow > EPSILON && underflow <= stretchCapacity + EPSILON) {
+		const resolved = resolveSpacings(pairValues, "stretch", underflow);
+		return {
+			start,
+			contentStart,
+			end,
+			suppressedIndexes,
+			pairSpacings: resolved.spacings,
+			inlineSizeEm: lineLengthEm,
+			break: { kind: "stretched" },
+			hangingIndex: null,
+			deformationRatio: stretchCapacity === 0 ? 0 : underflow / stretchCapacity,
+			priorityCost: resolved.priorityCost
+		};
+	}
+	return {
+		start,
+		contentStart,
+		end,
+		suppressedIndexes,
+		pairSpacings: resolveSpacings(pairValues, "natural", 0).spacings,
+		inlineSizeEm: naturalSizeEm,
+		break: { kind: "forced" },
+		hangingIndex: null,
+		deformationRatio: Math.abs(naturalSizeEm - lineLengthEm) / Math.max(lineLengthEm, EPSILON),
+		priorityCost: 0
+	};
+}
+function scoreFor(line, previousFitness) {
+	const mode = line.break.kind;
+	const fitness = Math.min(3, Math.floor(line.deformationRatio * 4));
+	const transition = Math.abs(previousFitness - fitness) > 1 ? 1 : 0;
+	const modeCounts = {
+		forced: mode === "forced" ? 1 : 0,
+		stretched: mode === "stretched" ? 1 : 0,
+		hanging: mode === "hanging" ? 1 : 0,
+		shrunk: mode === "shrunk" && line.priorityCost > EPSILON ? 1 : 0
+	};
+	return {
+		score: [
+			modeCounts.forced,
+			modeCounts.stretched,
+			modeCounts.hanging,
+			modeCounts.shrunk,
+			line.priorityCost,
+			line.deformationRatio ** 3,
+			transition
+		],
+		fitness
+	};
+}
+function addScore(left, right) {
+	return [
+		left[0] + right[0],
+		left[1] + right[1],
+		left[2] + right[2],
+		left[3] + right[3],
+		left[4] + right[4],
+		left[5] + right[5],
+		left[6] + right[6]
+	];
+}
+function compareBreaks(left, right) {
+	const length = Math.min(left.length, right.length);
+	for (let index = 0; index < length; index += 1) {
+		const difference = (right[index] ?? 0) - (left[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return left.length - right.length;
+}
+function isBetter(candidateState, current) {
+	if (current === void 0) return true;
+	for (let index = 0; index < candidateState.score.length; index += 1) {
+		const difference = (candidateState.score[index] ?? 0) - (current.score[index] ?? 0);
+		if (Math.abs(difference) > EPSILON) return difference < 0;
+	}
+	return compareBreaks(candidateState.breaks, current.breaks) < 0;
+}
+function layoutParagraph(atoms, lineLengthEm, profile, boundaryAllowed) {
+	if (atoms.length === 0) return [];
+	const classes = atoms.map(({ characterClass }) => characterClass);
+	const states = /* @__PURE__ */ new Map([[0, /* @__PURE__ */ new Map([[0, {
+		score: [
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		],
+		fitness: 0,
+		previous: null,
+		line: null,
+		breaks: []
+	}]])]]);
+	for (let start = 0; start < atoms.length; start += 1) {
+		const activeStates = states.get(start);
+		if (activeStates === void 0) continue;
+		const contentStart = skipSourceGaps(atoms, start);
+		if (contentStart === atoms.length) {
+			const terminalStates = states.get(atoms.length) ?? /* @__PURE__ */ new Map();
+			for (const state of activeStates.values()) if (isBetter(state, terminalStates.get(state.fitness))) terminalStates.set(state.fitness, state);
+			states.set(atoms.length, terminalStates);
+			continue;
+		}
+		for (const state of activeStates.values()) for (let end = contentStart + 1; end <= atoms.length; end += 1) {
+			const right = skipSourceGaps(atoms, end);
+			const left = previousVisible(atoms, end);
+			if (atoms[end - 1]?.sourceGap === true) continue;
+			if (end < atoms.length && right < atoms.length && (left === void 0 || !boundaryAllowed(left, right))) continue;
+			const line = candidate(atoms, classes, start, end, lineLengthEm, profile);
+			if (line.break.kind === "forced" && line.inlineSizeEm > lineLengthEm + EPSILON && Array.from({ length: end - contentStart - 1 }, (_, index) => contentStart + index + 1).some((boundary) => boundaryAllowed(boundary - 1, boundary))) {
+				if (line.inlineSizeEm > lineLengthEm * 2 && end > contentStart + 1) break;
+				continue;
+			}
+			const lineScore = scoreFor(line, state.fitness);
+			const nextState = {
+				score: addScore(state.score, lineScore.score),
+				fitness: lineScore.fitness,
+				previous: {
+					index: start,
+					fitness: state.fitness
+				},
+				line,
+				breaks: [...state.breaks, end]
+			};
+			const statesAtEnd = states.get(end) ?? /* @__PURE__ */ new Map();
+			if (isBetter(nextState, statesAtEnd.get(nextState.fitness))) {
+				statesAtEnd.set(nextState.fitness, nextState);
+				states.set(end, statesAtEnd);
+			}
+			if (line.inlineSizeEm > lineLengthEm * 2 && line.break.kind === "forced" && end > contentStart + 1) break;
+		}
+	}
+	const terminal = [...states.get(atoms.length)?.values() ?? []].reduce((best, state) => isBetter(state, best) ? state : best, void 0);
+	if (terminal === void 0) return [];
+	const lines = [];
+	let cursor = terminal;
+	while (cursor?.line !== null && cursor?.line !== void 0) {
+		lines.push(cursor.line);
+		cursor = cursor.previous === null ? void 0 : states.get(cursor.previous.index)?.get(cursor.previous.fitness);
+	}
+	lines.reverse();
+	const last = lines.at(-1);
+	if (last !== void 0 && last.end < atoms.length) lines[lines.length - 1] = {
+		...last,
+		suppressedIndexes: [...last.suppressedIndexes, ...Array.from({ length: atoms.length - last.end }, (_, index) => last.end + index)]
+	};
+	return lines;
+}
+//#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()
+}) };
+//#endregion
+//#region src/composer/composed-annotation-fragment.ts
+const emLength = () => v.pipe(v.number(), v.finite(), v.minValue(0));
+const continuation = v.union([
+	v.literal("whole"),
+	v.literal("start"),
+	v.literal("middle"),
+	v.literal("end")
+]);
+const PositionedReadingGraphemeSchema = readonlyObject({
+	value: v.string(),
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: emLength()
+});
+const common$1 = {
+	annotationRange: ManuscriptRange.schema,
+	fragmentRange: ManuscriptRange.schema,
+	continuation
+};
+const ComposedAnnotationFragment = { schema: v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("bold"),
+		...common$1
+	}),
+	readonlyObject({
+		kind: v.literal("italic"),
+		...common$1
+	}),
+	readonlyObject({
+		kind: v.literal("emphasis"),
+		mark: v.string(),
+		...common$1
+	}),
+	readonlyObject({
+		kind: v.literal("ruby"),
+		rubyKind: RubyKind.schema,
+		reading: v.string(),
+		baseOffsetEm: emLength(),
+		baseAdvanceEm: emLength(),
+		readingGraphemes: readonlyArray(PositionedReadingGraphemeSchema),
+		...common$1
+	})
+]) };
+const InlineSpan = { schema: readonlyObject({
+	offsetEm: v.pipe(v.number(), v.finite()),
+	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0))
+}) };
+//#endregion
+//#region src/composer/vertical-text-presentation.ts
+const common = { groupRange: ManuscriptRange.schema };
+const VerticalTextPresentation = { schema: v.variant("kind", [
+	readonlyObject({
+		kind: v.literal("mixed"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("upright"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("sideways"),
+		...common
+	}),
+	readonlyObject({
+		kind: v.literal("tate-chu-yoko"),
+		...common
+	})
+]) };
+//#endregion
+//#region src/composer/composed-inline-item.ts
+const signedEm = () => v.pipe(v.number(), v.finite());
+const GlyphItemSchema = readonlyObject({
+	kind: v.literal("glyph"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	layoutSpan: InlineSpan.schema,
+	renderSpan: InlineSpan.schema,
+	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
+	presentation: VerticalTextPresentation.schema
+});
+const GeneratedGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("generated"),
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const SourceGlueItemSchema = readonlyObject({
+	kind: v.literal("glue"),
+	origin: v.literal("source"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	offsetEm: signedEm(),
+	widthEm: signedEm(),
+	naturalWidthEm: signedEm(),
+	adjustment: v.union([
+		v.literal("natural"),
+		v.literal("shrunk"),
+		v.literal("stretched")
+	])
+});
+const KernItemSchema = readonlyObject({
+	kind: v.literal("kern"),
+	offsetEm: signedEm(),
+	widthEm: signedEm()
+});
+const SuppressedItemSchema = readonlyObject({
+	kind: v.literal("suppressed"),
+	value: v.string(),
+	range: ManuscriptRange.schema,
+	reason: v.literal("question-or-exclamation-gap")
+});
+const ComposedInlineItem = { schema: v.union([
+	GlyphItemSchema,
+	GeneratedGlueItemSchema,
+	SourceGlueItemSchema,
+	KernItemSchema,
+	SuppressedItemSchema
+]) };
+const 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: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		inlineSizeEm: v.pipe(v.number(), v.finite(), v.minValue(0)),
+		items: readonlyArray(ComposedInlineItem.schema),
+		break: LineBreakResult.schema,
+		annotations: readonlyArray(ComposedAnnotationFragment.schema)
+	}),
+	empty: () => ({
+		range: null,
+		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/novel-composer.ts
+const COMPOSER_ID = NamespacedId.of("kg/novel");
+const TYPESETTING_PROFILE = defaultJapaneseTypesettingProfile;
+const ASCII_ALPHANUMERIC = /^[A-Za-z0-9]$/u;
+const ASCII_TWO_DIGITS = /^[0-9]{2}$/u;
+const UPRIGHT_LATIN_ABBREVIATION = /^(?:[A-Z]+|[A-Z][a-z]{1,2})$/u;
+const FULLWIDTH_ALPHANUMERIC = /^[Ａ-Ｚａ-ｚ０-９]$/u;
+function presentation(kind, graphemes) {
+	const groupRange = ManuscriptRange.merge(graphemes.map(({ range }) => range));
+	return groupRange === null ? void 0 : {
+		kind,
+		groupRange
+	};
+}
+function presentedSourceLine(sourceLine) {
+	const presented = [];
+	let cursor = 0;
+	while (cursor < sourceLine.length) {
+		const first = sourceLine[cursor];
+		if (first === void 0) break;
+		if (!ASCII_ALPHANUMERIC.test(first.value)) {
+			const itemPresentation = presentation(FULLWIDTH_ALPHANUMERIC.test(first.value) ? "upright" : "mixed", [first]);
+			if (itemPresentation !== void 0) presented.push({
+				grapheme: first,
+				presentation: itemPresentation
+			});
+			cursor += 1;
+			continue;
+		}
+		const start = cursor;
+		while (ASCII_ALPHANUMERIC.test(sourceLine[cursor]?.value ?? "")) cursor += 1;
+		const run = sourceLine.slice(start, cursor);
+		const text = run.map(({ value }) => value).join("");
+		const runPresentation = presentation(ASCII_TWO_DIGITS.test(text) ? "tate-chu-yoko" : text.length === 1 || UPRIGHT_LATIN_ABBREVIATION.test(text) ? "upright" : "sideways", run);
+		if (runPresentation !== void 0) presented.push(...run.map((grapheme) => ({
+			grapheme,
+			presentation: runPresentation
+		})));
+	}
+	return presented;
+}
+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 validGapIndexes(sourceLine) {
+	const line = sourceLine.map(({ value }) => value).join("");
+	const gapStarts = new Set(questionOrExclamationSpacings(line).filter((spacing) => spacing.kind === "valid").map(({ gap }) => gap.start));
+	const indexes = /* @__PURE__ */ new Set();
+	let offset = 0;
+	for (const [index, grapheme] of sourceLine.entries()) {
+		if (gapStarts.has(offset)) indexes.add(index);
+		offset += grapheme.value.length;
+	}
+	return indexes;
+}
+function indicesInside(atoms, annotation) {
+	return atoms.flatMap(({ grapheme }, index) => ManuscriptRange.overlaps(grapheme.range, annotation.range) ? [index] : []);
+}
+function measure(measurer, text, role, settings, presentationKind) {
+	const context = {
+		text,
+		fontPreset: settings.appearance.fontPreset,
+		writingMode: "vertical-rl"
+	};
+	const measurement = role === "base" ? measurer({
+		...context,
+		role,
+		presentation: presentationKind ?? "mixed"
+	}) : measurer({
+		...context,
+		role
+	});
+	const parsed = v.safeParse(InlineMeasurement.schema, measurement);
+	if (!parsed.success) return void 0;
+	const { advanceEm } = parsed.output;
+	return advanceEm;
+}
+/**
+* Widen a base character by `extraEm` so a reading longer than it has room, keeping the character's
+* ink in the middle of the widened box.
+*
+* JLReq 3.3.6 sets such a reading solid and spends the surplus on the base instead: two units
+* between the base characters for one unit before the first and after the last. Handing every base
+* character an equal share of the surplus and centring it inside that share produces exactly those
+* proportions, and it is also the 中付き position JLReq 3.3.5 asks of a mono ruby whose reading
+* outruns its single base character.
+*/
+function widenForReading(atom, extraEm) {
+	if (extraEm <= 0) return;
+	atom.boxAdvanceEm += extraEm;
+	atom.renderOffsetEm += extraEm / 2;
+}
+function measureSourceLine(sourceLine, annotations, settings, measurer) {
+	const mutable = presentedSourceLine(sourceLine).map(({ grapheme, presentation }) => {
+		const renderAdvanceEm = measure(measurer, grapheme.value, "base", settings, presentation.kind);
+		if (renderAdvanceEm === void 0) return void 0;
+		const characterClass = TYPESETTING_PROFILE.classify({
+			value: grapheme.value,
+			presentation: presentation.kind
+		});
+		const metrics = TYPESETTING_PROFILE.boxMetrics(characterClass, renderAdvanceEm);
+		return {
+			grapheme,
+			boxAdvanceEm: metrics.advanceEm,
+			renderAdvanceEm,
+			renderOffsetEm: metrics.renderOffsetEm,
+			presentation
+		};
+	});
+	if (mutable.some((atom) => atom === void 0)) return void 0;
+	const atoms = mutable.flatMap((atom) => atom === void 0 ? [] : [atom]);
+	for (const annotation of annotations) {
+		if (annotation.kind !== "ruby") continue;
+		const indexes = indicesInside(atoms, annotation);
+		if (indexes.length === 0) continue;
+		if ((annotation.reading.kind === "group" ? [annotation.reading.text] : annotation.reading.segments).some((text) => [...graphemeSegmenter.segment(text)].some(({ segment }) => measure(measurer, segment, "ruby", settings) === void 0))) return void 0;
+		if (annotation.reading.kind === "group") {
+			const readingAdvance = measure(measurer, annotation.reading.text, "ruby", settings);
+			if (readingAdvance === void 0) return void 0;
+			const baseAdvance = indexes.reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0);
+			const extra = Math.max(0, readingAdvance - baseAdvance) / indexes.length;
+			for (const index of indexes) {
+				const atom = atoms[index];
+				if (atom !== void 0) widenForReading(atom, extra);
+			}
+			continue;
+		}
+		for (const [segmentIndex, index] of indexes.entries()) {
+			const segment = annotation.reading.segments[segmentIndex];
+			const atom = atoms[index];
+			if (segment === void 0 || atom === void 0) continue;
+			const readingAdvance = measure(measurer, segment, "ruby", settings);
+			if (readingAdvance === void 0) return void 0;
+			widenForReading(atom, readingAdvance - atom.boxAdvanceEm);
+		}
+	}
+	return {
+		atoms,
+		suppressedIndexes: validGapIndexes(sourceLine)
+	};
+}
+function breakInsideFittableGroupRuby(atoms, annotations, boundary, lineLengthEm) {
+	const right = atoms[boundary];
+	if (right === void 0) return false;
+	const graphemeIndex = right.grapheme.range.graphemes.start;
+	return annotations.some((annotation) => {
+		if (annotation.kind !== "ruby" || annotation.reading.kind !== "group") return false;
+		if (graphemeIndex <= annotation.range.graphemes.start || graphemeIndex >= annotation.range.graphemes.end) return false;
+		return indicesInside(atoms, annotation).reduce((total, index) => total + (atoms[index]?.boxAdvanceEm ?? 0), 0) <= lineLengthEm;
+	});
+}
+function samePresentationGroup(left, right) {
+	return left.presentation.groupRange.graphemes.start === right.presentation.groupRange.graphemes.start && left.presentation.groupRange.graphemes.end === right.presentation.groupRange.graphemes.end;
+}
+function legalBoundary(atoms, annotations, leftIndex, rightIndex, lineLengthEm, profile) {
+	const left = atoms[leftIndex];
+	const right = atoms[rightIndex];
+	if (left === void 0 || right === void 0) return true;
+	return !samePresentationGroup(left, right) && profile.breakPenalty(profile.classify({
+		value: left.grapheme.value,
+		presentation: left.presentation.kind
+	}), profile.classify({
+		value: right.grapheme.value,
+		presentation: right.presentation.kind
+	})) !== null && !breakInsideFittableGroupRuby(atoms, annotations, rightIndex, lineLengthEm);
+}
+function continuationFor(annotation, range) {
+	const starts = range.graphemes.start === annotation.range.graphemes.start;
+	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 groupReadingsForFragments(annotation, fragmentRanges, baseAdvances) {
+	const baseLength = annotation.range.graphemes.end - annotation.range.graphemes.start;
+	if (annotation.reading.kind !== "group") return [];
+	const reading = [...graphemeSegmenter.segment(annotation.reading.text)].map(({ segment }) => segment);
+	const advances = Array.from({ length: baseLength }, (_, index) => baseAdvances.get(annotation.range.graphemes.start + index));
+	const measured = advances.every((advance) => advance !== void 0);
+	const advanceFor = (fragment) => {
+		const fragmentStart = fragment.graphemes.start - annotation.range.graphemes.start;
+		const fragmentLength = fragment.graphemes.end - fragment.graphemes.start;
+		return measured ? advances.slice(fragmentStart, fragmentStart + fragmentLength).reduce((total, advance) => total + advance, 0) : fragmentLength;
+	};
+	const weights = fragmentRanges.map(advanceFor);
+	const effectiveWeights = weights.reduce((total, weight) => total + weight, 0) > 0 ? weights : fragmentRanges.map(({ graphemes }) => graphemes.end - graphemes.start);
+	const totalWeight = effectiveWeights.reduce((total, weight) => total + weight, 0);
+	const reserveEveryFragment = reading.length >= fragmentRanges.length;
+	const fragments = [];
+	let readingStart = 0;
+	let accumulatedWeight = 0;
+	for (const [index, weight] of effectiveWeights.entries()) {
+		accumulatedWeight += weight;
+		const remainingFragments = effectiveWeights.length - index - 1;
+		const proportionalEnd = index === effectiveWeights.length - 1 ? reading.length : Math.round(accumulatedWeight * reading.length / totalWeight);
+		const minimumEnd = reserveEveryFragment ? readingStart + 1 : readingStart;
+		const maximumEnd = reserveEveryFragment ? reading.length - remainingFragments : reading.length;
+		const readingEnd = Math.min(maximumEnd, Math.max(minimumEnd, proportionalEnd));
+		fragments.push(reading.slice(readingStart, readingEnd).join(""));
+		readingStart = readingEnd;
+	}
+	return fragments;
+}
+function readingForFragment(annotation, range, fragmentPlan) {
+	const start = range.graphemes.start - annotation.range.graphemes.start;
+	const length = range.graphemes.end - range.graphemes.start;
+	if (annotation.reading.kind !== "group") return {
+		kind: annotation.reading.kind,
+		text: annotation.reading.segments.slice(start, start + length).join("")
+	};
+	const fragmentIndex = fragmentPlan.ranges.findIndex(({ graphemes }) => graphemes.start === range.graphemes.start && graphemes.end === range.graphemes.end);
+	return {
+		kind: "group",
+		text: fragmentPlan.groupReadings[fragmentIndex] ?? ""
+	};
+}
+function positionReading(text, baseOffsetEm, baseAdvanceEm, settings, measurer) {
+	const measured = [...graphemeSegmenter.segment(text)].map(({ segment }) => ({
+		value: segment,
+		advanceEm: measure(measurer, segment, "ruby", settings) ?? 0
+	}));
+	const total = measured.reduce((sum, grapheme) => sum + grapheme.advanceEm, 0);
+	const edgeGap = measured.length > 0 && total < baseAdvanceEm ? (baseAdvanceEm - total) / (2 * measured.length) : 0;
+	let offsetEm = baseOffsetEm + (total > baseAdvanceEm ? (baseAdvanceEm - total) / 2 : edgeGap);
+	return measured.map((grapheme, index) => {
+		const positioned = {
+			value: grapheme.value,
+			advanceEm: grapheme.advanceEm,
+			offsetEm
+		};
+		offsetEm += grapheme.advanceEm;
+		if (index < measured.length - 1) offsetEm += edgeGap * 2;
+		return positioned;
+	});
+}
+function annotationFragmentRange(graphemes, suppressed, sourceGlues, annotation) {
+	return ManuscriptRange.merge([
+		...graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
+		...suppressed.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range),
+		...sourceGlues.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range)).map(({ range }) => range)
+	]);
+}
+function annotationFragments(graphemes, suppressed, sourceGlues, annotations, settings, measurer, fragmentPlansByAnnotation) {
+	const fragments = [];
+	for (const annotation of annotations) {
+		const covered = graphemes.filter(({ range }) => ManuscriptRange.overlaps(range, annotation.range));
+		const fragmentRange = annotationFragmentRange(graphemes, suppressed, 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,
+					...common
+				});
+				break;
+			case "ruby": {
+				const fragmentPlan = fragmentPlansByAnnotation.get(annotation);
+				if (fragmentPlan === void 0) break;
+				const baseOffsetEm = first.layoutSpan.offsetEm;
+				const baseAdvanceEm = last.layoutSpan.offsetEm + last.layoutSpan.advanceEm - baseOffsetEm;
+				const reading = readingForFragment(annotation, fragmentRange, fragmentPlan);
+				fragments.push({
+					kind: "ruby",
+					rubyKind: reading.kind,
+					reading: reading.text,
+					baseOffsetEm,
+					baseAdvanceEm,
+					readingGraphemes: positionReading(reading.text, baseOffsetEm, baseAdvanceEm, settings, measurer),
+					...common
+				});
+				break;
+			}
+		}
+	}
+	return fragments;
+}
+function positionedLine(atoms, sourceGapIndexes, plan) {
+	const items = plan.suppressedIndexes.flatMap((index) => {
+		const atom = atoms[index];
+		return atom === void 0 ? [] : [{
+			kind: "suppressed",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			reason: "question-or-exclamation-gap"
+		}];
+	});
+	const spacings = new Map(plan.pairSpacings.map((spacing) => [spacing.boundary, spacing]));
+	let offsetEm = 0;
+	const 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: spacing.widthEm < spacing.naturalWidthEm ? "shrunk" : spacing.widthEm > spacing.naturalWidthEm ? "stretched" : "natural"
+		});
+		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;
+		if (sourceGapIndexes.has(index)) {
+			items.push({
+				kind: "glue",
+				origin: "source",
+				value: atom.grapheme.value,
+				range: atom.grapheme.range,
+				offsetEm,
+				widthEm: atom.boxAdvanceEm,
+				naturalWidthEm: atom.boxAdvanceEm,
+				adjustment: "natural"
+			});
+			offsetEm += atom.boxAdvanceEm;
+			continue;
+		}
+		const hanging = plan.hangingIndex === index;
+		const layoutAdvanceEm = hanging ? 0 : atom.boxAdvanceEm;
+		items.push({
+			kind: "glyph",
+			value: atom.grapheme.value,
+			range: atom.grapheme.range,
+			layoutSpan: {
+				offsetEm,
+				advanceEm: layoutAdvanceEm
+			},
+			renderSpan: {
+				offsetEm: offsetEm + atom.renderOffsetEm,
+				advanceEm: atom.renderAdvanceEm
+			},
+			disposition: hanging ? "hanging" : "placed",
+			presentation: atom.presentation
+		});
+		offsetEm += layoutAdvanceEm;
+	}
+	const trailingSpacing = spacings.get(plan.end);
+	if (trailingSpacing !== void 0) positionSpacing(trailingSpacing);
+	const ranges = items.flatMap((item) => item.kind === "glyph" || item.kind === "suppressed" || item.kind === "glue" && item.origin === "source" ? [item.range] : []);
+	return {
+		range: ManuscriptRange.merge(ranges),
+		inlineSizeEm: Math.max(0, plan.inlineSizeEm),
+		items,
+		break: plan.break,
+		annotations: []
+	};
+}
+function wrapSourceLine(sourceLine, annotations, settings, measurer, baseAdvances) {
+	if (sourceLine.atoms.length === 0) return [NovelLine.empty()];
+	const profile = TYPESETTING_PROFILE;
+	const lines = layoutParagraph(sourceLine.atoms.map(({ grapheme, boxAdvanceEm, presentation }, index) => {
+		const current = sourceLine.atoms[index];
+		const next = sourceLine.atoms[index + 1];
+		return {
+			value: grapheme.value,
+			boxAdvanceEm,
+			sourceGap: sourceLine.suppressedIndexes.has(index),
+			characterClass: profile.classify({
+				value: grapheme.value,
+				presentation: presentation.kind
+			}),
+			pairSpacingAfter: current === void 0 || next === void 0 || !samePresentationGroup(current, next) && !breakInsideFittableGroupRuby(sourceLine.atoms, annotations, index + 1, settings.flow.lineLengthEm)
+		};
+	}), settings.flow.lineLengthEm, profile, (leftIndex, rightIndex) => legalBoundary(sourceLine.atoms, annotations, leftIndex, rightIndex, settings.flow.lineLengthEm, profile)).map((plan) => positionedLine(sourceLine.atoms, sourceLine.suppressedIndexes, plan));
+	const fragmentPlansByAnnotation = new Map(annotations.map((annotation) => {
+		const ranges = lines.flatMap((line) => {
+			const range = annotationFragmentRange(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotation);
+			return range === null ? [] : [range];
+		});
+		return [annotation, {
+			ranges,
+			groupReadings: annotation.kind === "ruby" ? groupReadingsForFragments(annotation, ranges, baseAdvances) : []
+		}];
+	}));
+	return lines.map((line) => ({
+		range: line.range,
+		inlineSizeEm: line.inlineSizeEm,
+		items: line.items,
+		break: line.break,
+		annotations: annotationFragments(line.items.filter((item) => item.kind === "glyph"), line.items.filter((item) => item.kind === "suppressed"), line.items.flatMap((item) => item.kind === "glue" && item.origin === "source" ? [item] : []), annotations, settings, measurer, fragmentPlansByAnnotation)
+	}));
+}
+function blankLines(count) {
+	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(measurer) {
+	return (manuscript, settings) => {
+		const sourceLines = displayedLines(manuscript.graphemes);
+		const measured = sourceLines.map((line) => measureSourceLine(line, manuscript.annotations, settings, measurer));
+		if (measured.some((line) => line === void 0)) return ManuscriptResult.fail({ reason: "inline measurer returned a negative or non-finite value" });
+		const baseAdvances = /* @__PURE__ */ new Map();
+		for (const line of measured) for (const atom of line?.atoms ?? []) baseAdvances.set(atom.grapheme.range.graphemes.start, atom.boxAdvanceEm);
+		const manuscriptLines = measured.flatMap((line) => line === void 0 ? [] : wrapSourceLine(line, manuscript.annotations, settings, measurer, baseAdvances));
+		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: logicalInlineMeasurer });
+//#endregion
+export { logicalInlineMeasurer as a, ManuscriptOffsets as c, FontSizePt as d, FontPresetId as f, PaperSize as i, ManuscriptAppearanceSettings as l, novelComposer as n, NovelCompositionSettings as o, ParsedManuscript as p, ManuscriptGeometry as r, NovelFlowSettings as s, createNovelComposer as t, PaperSizeId as u };