@sushichan044/kg-core 0.6.5 → 0.8.0

package/dist/index.mjs

@@ -1,429 +1,8 @@
+import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, l as ManuscriptDiagnostic, o as graphemeSegmenter, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
+import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-CROZLBqt.mjs";
+import { n as assertNever, t as describeCause } from "./describe-cause-BV8mZ3Um.mjs";
 import * as v from "valibot";
-import { eastAsianWidth } from "get-east-asian-width";
-//#region src/assert-never.ts
-/**
-* Marks a branch the compiler proved unreachable. Reaching it at runtime means a variant was added
-* to a union without updating the switch that produced this call.
-*/
-function assertNever(value) {
-	throw new TypeError(`unhandled variant: ${JSON.stringify(value)}`);
-}
-//#endregion
-//#region src/namespaced-id.ts
-const NamespacedIdSchema = v.pipe(v.string(), v.nonEmpty(), v.regex(/^[^/]+\/[^/]+$/u, "ID must use namespace/name"), v.brand("NamespacedId"));
-const NamespacedId = {
-	schema: NamespacedIdSchema,
-	/**
-	* For IDs written as literals in code. Throws on a malformed literal, at import time.
-	*/
-	of: (literal) => v.parse(NamespacedIdSchema, literal),
-	/**
-	* For IDs supplied by a plugin, where a malformed value is bad input rather than a bug.
-	*/
-	parse: (raw) => {
-		const result = v.safeParse(NamespacedIdSchema, raw);
-		return result.success ? result.output : void 0;
-	}
-};
-//#endregion
-//#region src/internal/schema.ts
-/**
-* Every DTO in this package is a closed, frozen object: unknown keys are rejected, output is
-* readonly.
-*/
-const readonlyObject = (entries) => v.pipe(v.strictObject(entries), v.readonly());
-const readonlyArray = (item) => v.pipe(v.array(item), v.readonly());
-const nonNegativeInteger = (maximum = Number.POSITIVE_INFINITY) => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(0), v.maxValue(maximum));
-const positiveInteger = () => v.pipe(v.number(), v.finite(), v.integer(), v.minValue(1));
-const TextRange = { schema: v.pipe(readonlyObject({
-	start: nonNegativeInteger(),
-	end: nonNegativeInteger()
-}), v.check(({ start, end }) => end >= start, "range end must not precede its start")) };
-const DisplayRange = { schema: v.pipe(TextRange.schema, v.brand("DisplayRange")) };
-const GraphemeRange = { schema: v.pipe(TextRange.schema, v.brand("GraphemeRange")) };
-const SourceRange = { schema: v.pipe(TextRange.schema, v.brand("SourceRange")) };
-//#endregion
-//#region src/range/manuscript-range.ts
-const ManuscriptRangeSchema = readonlyObject({
-	source: SourceRange.schema,
-	display: DisplayRange.schema,
-	graphemes: GraphemeRange.schema
-});
-const ManuscriptRange = {
-	schema: ManuscriptRangeSchema,
-	/**
-	* Brands a span core computed itself. Throws rather than returning a failure: the inputs come
-	* from core's own arithmetic, so a violated bound is a bug here, not bad data from a caller.
-	*/
-	of: (input) => v.parse(ManuscriptRangeSchema, input),
-	merge: (ranges) => {
-		const present = ranges.filter((range) => range !== null);
-		if (present.length === 0) return null;
-		return ManuscriptRange.of({
-			source: {
-				start: Math.min(...present.map(({ source }) => source.start)),
-				end: Math.max(...present.map(({ source }) => source.end))
-			},
-			display: {
-				start: Math.min(...present.map(({ display }) => display.start)),
-				end: Math.max(...present.map(({ display }) => display.end))
-			},
-			graphemes: {
-				start: Math.min(...present.map(({ graphemes }) => graphemes.start)),
-				end: Math.max(...present.map(({ graphemes }) => graphemes.end))
-			}
-		});
-	},
-	overlaps: (range, other) => range.graphemes.start < other.graphemes.end && range.graphemes.end > other.graphemes.start
-};
-const SourcePosition = {
-	schema: readonlyObject({
-		offset: nonNegativeInteger(),
-		line: positiveInteger(),
-		column: positiveInteger()
-	}),
-	/**
-	* Counts CRLF, CR and LF as one line break each; column is UTF-16 code units from line start.
-	*/
-	at: (source, offset) => {
-		let line = 1;
-		let lineStart = 0;
-		let index = 0;
-		while (index < offset) if (source[index] === "\r") {
-			index += source[index + 1] === "\n" ? 2 : 1;
-			line += 1;
-			lineStart = index;
-		} else if (source[index] === "\n") {
-			index += 1;
-			line += 1;
-			lineStart = index;
-		} else index += 1;
-		return {
-			offset,
-			line,
-			column: offset - lineStart + 1
-		};
-	}
-};
-const DiagnosticOrigin = { schema: v.variant("kind", [readonlyObject({
-	kind: v.literal("parser"),
-	id: NamespacedId.schema
-}), readonlyObject({
-	kind: v.literal("rule"),
-	id: NamespacedId.schema
-})]) };
-const DiagnosticSeverity = { schema: v.picklist(["warning", "error"]) };
-const ManuscriptDiagnostic = {
-	schema: readonlyObject({
-		id: v.string(),
-		origin: DiagnosticOrigin.schema,
-		severity: DiagnosticSeverity.schema,
-		message: v.string(),
-		range: ManuscriptRange.schema,
-		location: readonlyObject({
-			start: SourcePosition.schema,
-			end: SourcePosition.schema
-		})
-	}),
-	of: ({ source, origin, severity, code, message, range }) => ({
-		id: `${origin.kind}:${origin.id}:${code}:${range.source.start}:${range.source.end}`,
-		origin,
-		severity,
-		message,
-		range,
-		location: {
-			start: SourcePosition.at(source, range.source.start),
-			end: SourcePosition.at(source, range.source.end)
-		}
-	}),
-	/**
-	* Stable order for display: by source span, then by producing plugin.
-	*/
-	compare: (left, right) => left.range.source.start - right.range.source.start || left.range.source.end - right.range.source.end || left.origin.id.localeCompare(right.origin.id)
-};
-//#endregion
-//#region src/result/manuscript-result.ts
-const ManuscriptResult = {
-	succeed: (value, warnings = []) => ({
-		ok: true,
-		value,
-		warnings
-	}),
-	fail: (error) => ({
-		ok: false,
-		error
-	}),
-	/**
-	* Validates a result that crossed a plugin boundary, including the diagnostics it carries.
-	*/
-	schema: (value, error) => v.variant("ok", [readonlyObject({
-		ok: v.literal(true),
-		value,
-		warnings: readonlyArray(ManuscriptDiagnostic.schema)
-	}), readonlyObject({
-		ok: v.literal(false),
-		error
-	})])
-};
-const Rejection = {
-	schema: readonlyObject({ reason: v.string() }),
-	of: (reason) => ({ reason })
-};
-const ValidationIssue = {
-	schema: readonlyObject({
-		path: v.string(),
-		message: v.string()
-	}),
-	from: (issues) => issues.map((issue) => ({
-		path: (issue.path ?? []).map((item) => String(item.key)).join("."),
-		message: issue.message
-	}))
-};
-//#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"
-	}
-};
-//#endregion
-//#region src/appearance/font-preset.ts
-const FONT_PRESETS = {
-	mincho: {
-		id: "mincho",
-		label: "明朝",
-		family: "\"Yu Mincho\", \"Hiragino Mincho ProN\", \"Hiragino Mincho Pro\", serif"
-	},
-	gothic: {
-		id: "gothic",
-		label: "ゴシック",
-		family: "\"Yu Gothic\", \"Hiragino Kaku Gothic ProN\", system-ui, sans-serif"
-	}
-};
-const FontPreset = {
-	of: (id) => FONT_PRESETS[id],
-	all: Object.values(FONT_PRESETS)
-};
-//#endregion
-//#region src/appearance/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/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)
-};
-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 RubyReading = { schema: RubyReadingSchema };
-const RubyAnnotation = { schema: RubyAnnotationSchema };
-const ManuscriptAnnotation = {
-	schema: v.variant("kind", [
-		RubyAnnotation.schema,
-		BoldAnnotation.schema,
-		ItalicAnnotation.schema,
-		EmphasisAnnotation.schema
-	]),
-	overlapping: (annotations, range) => annotations.filter((annotation) => ManuscriptRange.overlaps(annotation.range, range)),
-	/**
-	* 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)
-};
-//#endregion
-//#region src/internal/describe-cause.ts
-/**
-* Renders an unknown throwable for display, without assuming it is an Error.
-*/
-function describeCause(cause) {
-	return cause instanceof Error ? cause.message : String(cause);
-}
-//#endregion
-//#region src/parser/parse-error.ts
-const ParseError = { 
-/**
-* Human-readable rendering. Branch on `kind` instead when the caller needs to react.
-*/
-describe: (error) => {
-	switch (error.kind) {
-		case "InvalidParserId": return `パーサー ID "${error.parserId}" は namespace/name の形式ではありません`;
-		case "InvalidParserOutput": return `パーサー ${error.parserId} の出力が契約を満たしていません: ${error.issues.map(({ message }) => message).join(", ")}`;
-		case "ParserRejected": return `パーサー ${error.parserId} が解析を中止しました: ${error.reason}`;
-		case "ParserThrew": return `パーサー ${error.parserId} が例外を投げました: ${describeCause(error.cause)}`;
-		default: return assertNever(error);
-	}
-} };
-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/internal/segmenter.ts
-/**
-* Shared across parsing and proofreading so both agree on what counts as one grapheme.
-*/
-const graphemeSegmenter = new Intl.Segmenter("ja", { granularity: "grapheme" });
+const Rejection = { schema: readonlyObject({ reason: v.string() }) };
 //#endregion
 //#region src/parser/internal/manuscript-draft.ts
 /**
@@ -550,6 +129,21 @@ function parseManuscript(source, options = {}) {
 	});
 }
 //#endregion
+//#region src/parser/parse-error.ts
+const ParseError = { 
+/**
+* Human-readable rendering. Branch on `kind` instead when the caller needs to react.
+*/
+describe: (error) => {
+	switch (error.kind) {
+		case "InvalidParserId": return `パーサー ID "${error.parserId}" は namespace/name の形式ではありません`;
+		case "InvalidParserOutput": return `パーサー ${error.parserId} の出力が契約を満たしていません: ${error.issues.map(({ message }) => message).join(", ")}`;
+		case "ParserRejected": return `パーサー ${error.parserId} が解析を中止しました: ${error.reason}`;
+		case "ParserThrew": return `パーサー ${error.parserId} が例外を投げました: ${describeCause(error.cause)}`;
+		default: return assertNever(error);
+	}
+} };
+//#endregion
 //#region src/parser/internal/line-end.ts
 /**
 * Returns the first line terminator at or after start. Both halves of CRLF remain outside the line.
@@ -934,26 +528,6 @@ const pixivParser = {
 	}
 };
 //#endregion
-//#region src/composer/compose-error.ts
-const ComposeError = { 
-/**
-* Human-readable rendering. Branch on `kind` instead when the caller needs to react.
-*/
-describe: (error) => {
-	switch (error.kind) {
-		case "InvalidComposerId": return `組版エンジン ID "${error.composerId}" は namespace/name の形式ではありません`;
-		case "InvalidManuscript": return `解析済み原稿が不正です: ${joinIssues$1(error.issues)}`;
-		case "InvalidSettings": return `組版設定が ${error.composerId} の要求を満たしていません: ${joinIssues$1(error.issues)}`;
-		case "InvalidComposerOutput": return `組版エンジン ${error.composerId} の出力が契約を満たしていません: ${joinIssues$1(error.issues)}`;
-		case "ComposerRejected": return `組版エンジン ${error.composerId} が組版を中止しました: ${error.reason}`;
-		case "ComposerThrew": return `組版エンジン ${error.composerId} が例外を投げました: ${describeCause(error.cause)}`;
-		default: return assertNever(error);
-	}
-} };
-function joinIssues$1(issues) {
-	return issues.map(({ message }) => message).join(", ");
-}
-//#endregion
 //#region src/composer/compose-manuscript.ts
 function composeManuscript(parsed, options) {
 	const { composer } = options;
@@ -1003,2041 +577,42 @@ function composeManuscript(parsed, options) {
 	}, result.warnings);
 }
 //#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 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
-	}),
-	maxDocumentOffset: MAX_DOCUMENT_OFFSET,
-	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 CompositionStatistics = { schema: readonlyObject({
-	chars: nonNegativeInteger(),
-	sourceLines: nonNegativeInteger(),
-	pages: nonNegativeInteger()
-}) };
-const InlineSpan = { schema: readonlyObject({
-	offsetEm: v.pipe(v.number(), v.finite()),
-	advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0))
-}) };
-//#endregion
-//#region src/composer/vertical-text-presentation.ts
-const common = { groupRange: ManuscriptRange.schema };
-const VerticalTextPresentation = { schema: v.variant("kind", [
-	readonlyObject({
-		kind: v.literal("mixed"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("upright"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("sideways"),
-		...common
-	}),
-	readonlyObject({
-		kind: v.literal("tate-chu-yoko"),
-		...common
-	})
-]) };
-//#endregion
-//#region src/composer/composed-inline-item.ts
-const signedEm = () => v.pipe(v.number(), v.finite());
-const GlyphItemSchema = readonlyObject({
-	kind: v.literal("glyph"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	layoutSpan: InlineSpan.schema,
-	renderSpan: InlineSpan.schema,
-	disposition: v.union([v.literal("placed"), v.literal("hanging")]),
-	presentation: VerticalTextPresentation.schema
-});
-const GeneratedGlueItemSchema = readonlyObject({
-	kind: v.literal("glue"),
-	origin: v.literal("generated"),
-	offsetEm: signedEm(),
-	widthEm: signedEm(),
-	naturalWidthEm: signedEm(),
-	adjustment: v.union([
-		v.literal("natural"),
-		v.literal("shrunk"),
-		v.literal("stretched")
-	])
-});
-const SourceGlueItemSchema = readonlyObject({
-	kind: v.literal("glue"),
-	origin: v.literal("source"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	offsetEm: signedEm(),
-	widthEm: signedEm(),
-	naturalWidthEm: signedEm(),
-	adjustment: v.union([
-		v.literal("natural"),
-		v.literal("shrunk"),
-		v.literal("stretched")
-	])
-});
-const KernItemSchema = readonlyObject({
-	kind: v.literal("kern"),
-	offsetEm: signedEm(),
-	widthEm: signedEm()
-});
-const SuppressedItemSchema = readonlyObject({
-	kind: v.literal("suppressed"),
-	value: v.string(),
-	range: ManuscriptRange.schema,
-	reason: v.literal("question-or-exclamation-gap")
-});
-const ComposedInlineItem = { schema: v.union([
-	GlyphItemSchema,
-	GeneratedGlueItemSchema,
-	SourceGlueItemSchema,
-	KernItemSchema,
-	SuppressedItemSchema
-]) };
-const InlineMeasurement = { schema: readonlyObject({ advanceEm: v.pipe(v.number(), v.finite(), v.minValue(0)) }) };
-function graphemeWidth(grapheme) {
-	let width = 1;
-	for (const character of grapheme) {
-		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 };
-};
-const LineBreakResult = { schema: v.variant("kind", [
-	readonlyObject({ kind: v.literal("natural") }),
-	readonlyObject({ kind: v.literal("shrunk") }),
-	readonlyObject({ kind: v.literal("stretched") }),
-	readonlyObject({ kind: v.literal("hanging") }),
-	readonlyObject({ kind: v.literal("forced") }),
-	readonlyObject({ kind: v.literal("paragraph-end") })
-]) };
-//#endregion
-//#region src/composer/manuscript-geometry.ts
-const STAGE_GAP_CELLS = 2;
-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);
-}
+//#region src/composer/compose-error.ts
+const ComposeError = { 
 /**
-* Every vertical line side by side, plus the gap between adjacent lines.
+* Human-readable rendering. Branch on `kind` instead when the caller needs to react.
 */
-function contentWidthInEm(flow) {
-	return flow.linesPerStage + LINE_GAP_CELLS * (flow.linesPerStage - 1);
+describe: (error) => {
+	switch (error.kind) {
+		case "InvalidComposerId": return `組版エンジン ID "${error.composerId}" は namespace/name の形式ではありません`;
+		case "InvalidManuscript": return `解析済み原稿が不正です: ${joinIssues(error.issues)}`;
+		case "InvalidSettings": return `組版設定が ${error.composerId} の要求を満たしていません: ${joinIssues(error.issues)}`;
+		case "InvalidComposerOutput": return `組版エンジン ${error.composerId} の出力が契約を満たしていません: ${joinIssues(error.issues)}`;
+		case "ComposerRejected": return `組版エンジン ${error.composerId} が組版を中止しました: ${error.reason}`;
+		case "ComposerThrew": return `組版エンジン ${error.composerId} が例外を投げました: ${describeCause(error.cause)}`;
+		default: return assertNever(error);
+	}
+} };
+function joinIssues(issues) {
+	return issues.map(({ message }) => message).join(", ");
 }
-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
-		};
+//#endregion
+//#region src/appearance/font-preset.ts
+const FONT_PRESETS = {
+	mincho: {
+		id: "mincho",
+		label: "明朝",
+		family: "\"Yu Mincho\", \"Hiragino Mincho ProN\", \"Hiragino Mincho Pro\", serif"
 	},
-	/**
-	* 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));
+	gothic: {
+		id: "gothic",
+		label: "ゴシック",
+		family: "\"Yu Gothic\", \"Hiragino Kaku Gothic ProN\", system-ui, sans-serif"
 	}
 };
-//#endregion
-//#region src/internal/japanese-brackets.ts
-/**
-* Brackets and quotes a Japanese paragraph may open with. Halfwidth forms are included because a
-* manuscript that uses them is still opening a paragraph, not writing prose.
-*/
-const OPENING_BRACKETS = "「『〖〈《（(“\"‘'［[〔｛{＜<";
-/**
-* The closing counterparts, in the same order.
-*/
-const CLOSING_BRACKETS = "」』〗〉》）)”\"’'］]〕｝}＞>";
-/**
-* Escapes the characters a regular expression character class would otherwise read as syntax, so a
-* set declared above can be dropped into a pattern.
-*/
-function characterClass(characters) {
-	return characters.replaceAll(/[\\\]^-]/gu, "\\$&");
-}
-//#endregion
-//#region src/internal/japanese-spaces.ts
-const LEADING_SPACES = /^[　 \t]+/u;
-/**
-* The run of spaces the text begins with, or an empty string. Halfwidth spaces and tabs count: a
-* rule has to see them to say they are the wrong space.
-*/
-function leadingSpaces(text) {
-	return LEADING_SPACES.exec(text)?.[0] ?? "";
-}
-//#endregion
-//#region src/internal/question-or-exclamation-spacing.ts
-/**
-* Runs, not single marks: `！？` is one mark and takes one gap, so the gap belongs after the run.
-*/
-const MARKS = /[？！]+/gu;
-function analyzeMatch(line, marks) {
-	const start = marks.index;
-	if (start === void 0) return void 0;
-	const marksRange = {
-		start,
-		end: start + marks[0].length
-	};
-	const next = line[marksRange.end];
-	if (next === void 0 || "」』〗〉》）)”\"’'］]〕｝}＞>".includes(next)) return void 0;
-	const spaces = leadingSpaces(line.slice(marksRange.end));
-	if (spaces === "") return {
-		kind: "missing",
-		marks: marksRange
-	};
-	const gap = {
-		start: marksRange.end,
-		end: marksRange.end + spaces.length
-	};
-	const following = line[gap.end];
-	if (following !== void 0 && "」』〗〉》）)”\"’'］]〕｝}＞>".includes(following)) return {
-		kind: "before-closing-bracket",
-		marks: marksRange,
-		gap
-	};
-	if (spaces !== "　") return {
-		kind: "invalid-space",
-		marks: marksRange,
-		gap
-	};
-	return {
-		kind: "valid",
-		marks: marksRange,
-		gap
-	};
-}
-/**
-* Classifies the spacing after each run of fullwidth question or exclamation marks in one display
-* line. Runs at the end of the line or immediately before a closing bracket need no gap and are
-* omitted from the result.
-*/
-function questionOrExclamationSpacings(line) {
-	return [...line.matchAll(MARKS)].map((marks) => analyzeMatch(line, marks)).filter((spacing) => spacing !== void 0);
-}
-//#endregion
-//#region src/composer/internal/japanese-typesetting-profile.ts
-const OPENING = /* @__PURE__ */ new Set(`${OPENING_BRACKETS}【〘〝｟«`);
-const CLOSING = /* @__PURE__ */ new Set(`${CLOSING_BRACKETS}】〙〟｠»`);
-const HYPHENS = /* @__PURE__ */ new Set("‐‑⁃–");
-const DIVIDING_PUNCTUATION = /* @__PURE__ */ new Set("！？‼⁇⁈⁉");
-const MIDDLE_DOTS = /* @__PURE__ */ new Set("・：；");
-const SMALL_KANA = /* @__PURE__ */ new Set("ァィゥェォッャュョヮヵヶぁぃぅぇぉっゃゅょゎゕゖ");
-const ITERATION_MARKS = /* @__PURE__ */ new Set("ヽヾゝゞ々〻");
-const INSEPARABLE = /* @__PURE__ */ new Set("—―…‥─〳〵");
-const PREFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("￥＄£#＃");
-const POSTFIXED_ABBREVIATIONS = /* @__PURE__ */ new Set("°′″％‰");
-const UNIT_SYMBOLS = /* @__PURE__ */ new Set("℃℉㎀㎁㎂㎃㎄㎅㎆㎇㎈㎉㎊㎋㎌㎍㎎㎏㎐㎑㎒㎓㎔㎕㎖㎗㎘㎙㎚㎛㎜㎝㎞㎟㎠㎡㎢");
-const GROUPED_NUMERAL = /^[0-9０-９]$/u;
-const HIRAGANA = /^\p{Script=Hiragana}$/u;
-const KATAKANA = /^\p{Script=Katakana}$/u;
-const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
-function classify({ value, presentation }) {
-	if (presentation === "tate-chu-yoko") return "cl-30";
-	if (OPENING.has(value)) return "cl-01";
-	if (CLOSING.has(value)) return "cl-02";
-	if (HYPHENS.has(value)) return "cl-03";
-	if (DIVIDING_PUNCTUATION.has(value)) return "cl-04";
-	if (MIDDLE_DOTS.has(value)) return "cl-05";
-	if (value === "。" || value === "．") return "cl-06";
-	if (value === "、" || value === "，") return "cl-07";
-	if (INSEPARABLE.has(value)) return "cl-08";
-	if (ITERATION_MARKS.has(value)) return "cl-09";
-	if (value === "ー") return "cl-10";
-	if (SMALL_KANA.has(value)) return "cl-11";
-	if (PREFIXED_ABBREVIATIONS.has(value)) return "cl-12";
-	if (POSTFIXED_ABBREVIATIONS.has(value)) return "cl-13";
-	if (value === "　") return "cl-14";
-	if (HIRAGANA.test(value)) return "cl-15";
-	if (KATAKANA.test(value)) return "cl-16";
-	if (GROUPED_NUMERAL.test(value)) return "cl-24";
-	if (UNIT_SYMBOLS.has(value)) return "cl-25";
-	if (value === " ") return "cl-26";
-	if (WESTERN.test(value)) return "cl-27";
-	return "cl-19";
-}
-function pairSpacing(left, right) {
-	if (left === "cl-08" && right === "cl-08") return {
-		kind: "kern",
-		naturalWidthEm: 0
-	};
-	if (left === "cl-01" && right === "cl-01" || left === "cl-02" && right === "cl-02") return {
-		kind: "kern",
-		naturalWidthEm: -.5
-	};
-	if (left === "cl-07" || left === "cl-06") return {
-		kind: "glue",
-		naturalWidthEm: .5,
-		shrink: {
-			priority: 1,
-			amountEm: .5
-		}
-	};
-	if (left === "cl-02" || right === "cl-01") return {
-		kind: "glue",
-		naturalWidthEm: .5,
-		shrink: {
-			priority: 2,
-			amountEm: .5
-		}
-	};
-	return {
-		kind: "glue",
-		naturalWidthEm: 0,
-		stretch: {
-			priority: 3,
-			amountEm: .25
-		}
-	};
-}
-function breakPenalty(left, right) {
-	if (left === "cl-01" || left === "cl-12") return null;
-	if (right === "cl-02" || right === "cl-03" || right === "cl-04" || right === "cl-05" || right === "cl-06" || right === "cl-07" || right === "cl-09" || right === "cl-10" || right === "cl-11" || right === "cl-13") return null;
-	if (left === "cl-08" && right === "cl-08") return null;
-	return 0;
-}
-const defaultJapaneseTypesettingProfile = {
-	classify,
-	boxMetrics: (characterClass, measuredAdvanceEm) => ({
-		advanceEm: characterClass === "cl-01" || characterClass === "cl-02" || characterClass === "cl-06" || characterClass === "cl-07" ? Math.min(.5, measuredAdvanceEm) : measuredAdvanceEm,
-		renderOffsetEm: characterClass === "cl-01" ? -.5 : 0
-	}),
-	pairSpacing,
-	lineStartSpacing: (first) => first === "cl-01" ? {
-		kind: "glue",
-		naturalWidthEm: .5,
-		shrink: {
-			priority: 2,
-			amountEm: .5
-		}
-	} : null,
-	lineEndSpacing: (last) => last === "cl-02" || last === "cl-06" || last === "cl-07" ? {
-		kind: "glue",
-		naturalWidthEm: .5,
-		shrink: {
-			priority: 0,
-			amountEm: .5
-		}
-	} : null,
-	breakPenalty,
-	canHang: (characterClass) => characterClass === "cl-07" || characterClass === "cl-06"
+const FontPreset = {
+	of: (id) => FONT_PRESETS[id],
+	all: Object.values(FONT_PRESETS)
 };
 //#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;
-}
-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;
-}
-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) atom.boxAdvanceEm += 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;
-			atom.boxAdvanceEm = Math.max(atom.boxAdvanceEm, readingAdvance);
-		}
-	}
-	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
-//#region src/proofreading/invalid-rule-options.ts
-const InvalidRuleOptions = { describe: (error) => `ルール ${error.ruleId} のオプション "${error.option}" が不正です: ${error.issues.map(({ message }) => message).join(", ")}` };
-//#endregion
-//#region src/proofreading/proofread-error.ts
-const ProofreadError = { 
-/**
-* Human-readable rendering. Branch on `kind` instead when the caller needs to react.
-*/
-describe: (error) => {
-	switch (error.kind) {
-		case "InvalidRuleId": return `ルール ID "${error.ruleId}" は namespace/name の形式ではありません`;
-		case "DuplicateRuleId": return `ルール ID ${error.ruleId} が重複しています`;
-		case "InvalidRuleMetadata": return `ルール ${error.ruleId} の metadata が不正です: ${joinIssues(error.issues)}`;
-		case "InvalidReport": return `ルール ${error.ruleId} の報告が契約を満たしていません: ${joinIssues(error.issues)}`;
-		case "UnknownMessageId": return `ルール ${error.ruleId} が未宣言のメッセージ ID "${error.messageId}" を報告しました`;
-		case "RuleThrew": return `ルール ${error.ruleId} が例外を投げました: ${describeCause(error.cause)}`;
-		default: return assertNever(error);
-	}
-} };
-function joinIssues(issues) {
-	return issues.map(({ message }) => message).join(", ");
-}
-//#endregion
-//#region src/proofreading/internal/interpolate.ts
-/**
-* Fills `{{ name }}` placeholders from the report's data; an absent key renders as empty.
-*/
-function interpolate(template, data) {
-	return template.replaceAll(/\{\{\s*([^}\s]+)\s*\}\}/gu, (_match, key) => String(data?.[key] ?? ""));
-}
-const ProofreadingReport = { schema: readonlyObject({
-	range: ManuscriptRange.schema,
-	messageId: v.string(),
-	data: v.optional(v.pipe(v.record(v.string(), v.union([v.string(), v.number()])), v.readonly())),
-	/**
-	* Omitted means `error`: a rule that says nothing is claiming it found a real defect.
-	*/
-	severity: v.optional(DiagnosticSeverity.schema)
-}) };
-//#endregion
-//#region src/proofreading/proofreading-rule.ts
-const ProofreadingRuleMessagesSchema = v.pipe(v.record(v.string(), v.string()), v.readonly());
-const ProofreadingRuleMeta = {
-	schema: readonlyObject({
-		id: v.string(),
-		messages: ProofreadingRuleMessagesSchema
-	}),
-	messagesSchema: ProofreadingRuleMessagesSchema
-};
-//#endregion
-//#region src/proofreading/proofread-manuscript.ts
-const reportsSchema = readonlyArray(ProofreadingReport.schema);
-function prepareRules(rules) {
-	const prepared = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const rule of rules) {
-		const id = NamespacedId.parse(rule.meta.id);
-		if (id === void 0) return ManuscriptResult.fail({
-			kind: "InvalidRuleId",
-			ruleId: rule.meta.id
-		});
-		if (seen.has(id)) return ManuscriptResult.fail({
-			kind: "DuplicateRuleId",
-			ruleId: id
-		});
-		const messages = v.safeParse(ProofreadingRuleMeta.messagesSchema, rule.meta.messages);
-		if (!messages.success) return ManuscriptResult.fail({
-			kind: "InvalidRuleMetadata",
-			ruleId: id,
-			issues: ValidationIssue.from(messages.issues)
-		});
-		seen.add(id);
-		prepared.push({
-			id,
-			messages: messages.output,
-			rule
-		});
-	}
-	return ManuscriptResult.succeed(prepared);
-}
-/**
-* Runs one rule and returns what it reported. A composed-only rule against a parsed manuscript is
-* simply skipped: the caller asked for a stage this rule cannot see.
-*/
-function collectReports({ id, rule }, parsed, composed) {
-	const reports = [];
-	const context = { report: (report) => {
-		reports.push(report);
-	} };
-	try {
-		switch (rule.kind) {
-			case "parsed":
-				rule.check(parsed, context);
-				break;
-			case "composed":
-				if (composed !== null) rule.check(composed, context);
-				break;
-			default: assertNever(rule);
-		}
-	} catch (cause) {
-		return ManuscriptResult.fail({
-			kind: "RuleThrew",
-			ruleId: id,
-			cause
-		});
-	}
-	const validated = v.safeParse(reportsSchema, reports);
-	return validated.success ? ManuscriptResult.succeed(validated.output) : ManuscriptResult.fail({
-		kind: "InvalidReport",
-		ruleId: id,
-		issues: ValidationIssue.from(validated.issues)
-	});
-}
-function toDiagnostics({ id, messages }, reports, source) {
-	const diagnostics = [];
-	for (const report of reports) {
-		const template = messages[report.messageId];
-		if (template === void 0) return ManuscriptResult.fail({
-			kind: "UnknownMessageId",
-			ruleId: id,
-			messageId: report.messageId
-		});
-		diagnostics.push(ManuscriptDiagnostic.of({
-			source,
-			origin: {
-				kind: "rule",
-				id
-			},
-			severity: report.severity ?? "error",
-			code: report.messageId,
-			message: interpolate(template, report.data),
-			range: report.range
-		}));
-	}
-	return ManuscriptResult.succeed(diagnostics);
-}
-function run(parsed, composed, rules) {
-	const prepared = prepareRules(rules);
-	if (!prepared.ok) return prepared;
-	const diagnostics = [];
-	for (const rule of prepared.value) {
-		const reports = collectReports(rule, parsed, composed);
-		if (!reports.ok) return reports;
-		const produced = toDiagnostics(rule, reports.value, parsed.source);
-		if (!produced.ok) return produced;
-		diagnostics.push(...produced.value);
-	}
-	return ManuscriptResult.succeed([...diagnostics].sort(ManuscriptDiagnostic.compare));
-}
-function proofreadManuscript(manuscript, options) {
-	return "composerId" in manuscript ? run(manuscript.parsed, manuscript, options.rules) : run(manuscript, null, options.rules);
-}
-//#endregion
-//#region src/proofreading/rules/internal/display-line.ts
-/**
-* Splits on CRLF, CR and LF. The text after the last break is always emitted, even when empty.
-*/
-function splitDisplayLines(text) {
-	const lines = [];
-	let start = 0;
-	let index = 0;
-	while (index < text.length) {
-		const character = text[index];
-		if (character !== "\n" && character !== "\r") {
-			index += 1;
-			continue;
-		}
-		lines.push({
-			text: text.slice(start, index),
-			start
-		});
-		index += character === "\r" && text[index + 1] === "\n" ? 2 : 1;
-		start = index;
-	}
-	lines.push({
-		text: text.slice(start),
-		start
-	});
-	return lines;
-}
-//#endregion
-//#region src/proofreading/rules/internal/rule-range.ts
-const EMPTY_BOUNDS = {
-	start: 0,
-	end: 0
-};
-/**
-* Turns a span of display text into a full range. The source span is the smallest contiguous run
-* that covers the display span, so it includes any notation the parser removed in between.
-*/
-function displayRange(manuscript, start, end) {
-	const covered = manuscript.graphemes.filter(({ range }) => range.display.start < end && range.display.end > start);
-	const first = covered[0];
-	const last = covered.at(-1);
-	if (first === void 0 || last === void 0) return ManuscriptRange.of({
-		source: EMPTY_BOUNDS,
-		display: {
-			start,
-			end
-		},
-		graphemes: EMPTY_BOUNDS
-	});
-	const merged = ManuscriptRange.merge(covered.map(({ range }) => range));
-	return ManuscriptRange.of({
-		source: {
-			start: first.range.source.start + clampWithin(start - first.range.display.start, first.range),
-			end: end === last.range.display.end ? last.range.source.end : last.range.source.start + clampWithin(end - last.range.display.start, last.range)
-		},
-		display: {
-			start,
-			end
-		},
-		graphemes: merged?.graphemes ?? EMPTY_BOUNDS
-	});
-}
-/**
-* A display offset inside a grapheme cannot map past that grapheme's own source span.
-*/
-function clampWithin(offset, range) {
-	return Math.min(offset, range.source.end - range.source.start);
-}
-/**
-* Turns a span of source text into a full range, for rules that inspect the raw source.
-*/
-function sourceRange(manuscript, source) {
-	const covered = manuscript.graphemes.filter(({ range }) => range.source.start < source.end && range.source.end > source.start);
-	const enclosing = manuscript.annotations.find(({ range }) => range.source.start <= source.start && range.source.end >= source.end);
-	const merged = ManuscriptRange.merge(covered.map(({ range }) => range)) ?? enclosing?.range ?? null;
-	return ManuscriptRange.of({
-		source,
-		display: merged?.display ?? EMPTY_BOUNDS,
-		graphemes: merged?.graphemes ?? EMPTY_BOUNDS
-	});
-}
-//#endregion
-//#region src/proofreading/rules/internal/define-rule.ts
-const DEFAULT_MESSAGE_ID = "default";
-/**
-* Builds a single-message rule; the body reports ranges and the wrapper names the message.
-*/
-function defineParsedRule(id, message, check) {
-	return {
-		kind: "parsed",
-		meta: {
-			id,
-			messages: { [DEFAULT_MESSAGE_ID]: message }
-		},
-		check: (manuscript, context) => {
-			check(manuscript, (range, options) => {
-				context.report({
-					...options,
-					range,
-					messageId: DEFAULT_MESSAGE_ID
-				});
-			});
-		}
-	};
-}
-/**
-* Builds a rule that scans each display line with a sticky pattern. Matching per line rather than
-* across the whole text keeps findings from spanning a line break.
-*/
-function defineMatchRule(options) {
-	return defineParsedRule(options.id, options.message, (manuscript, report) => {
-		for (const line of splitDisplayLines(manuscript.displayText)) {
-			options.pattern.lastIndex = 0;
-			let match = options.pattern.exec(line.text);
-			while (match !== null) {
-				if (options.accept?.(match) ?? true) {
-					const start = line.start + match.index;
-					report(displayRange(manuscript, start, start + match[0].length));
-				}
-				match = options.pattern.exec(line.text);
-			}
-		}
-	});
-}
-//#endregion
-//#region src/proofreading/rules/consistent-kanji-opening.ts
-const RULE_ID$5 = "kg/consistent-kanji-opening";
-const MESSAGE = "「{{ closed }}」と「{{ opened }}」が混在しています。文脈上の使い分けか表記ゆれかを確認してください";
-const KanjiOpeningPairSchema = v.pipe(readonlyObject({
-	closed: v.pipe(v.string(), v.nonEmpty()),
-	opened: v.pipe(v.string(), v.nonEmpty())
-}), v.check(({ closed, opened }) => closed !== opened, "a pair must hold two different spellings"));
-const PairsSchema = v.pipe(v.array(KanjiOpeningPairSchema), v.nonEmpty(), v.readonly());
-const DEFAULT_PAIRS = [
-	{
-		closed: "出来る",
-		opened: "できる"
-	},
-	{
-		closed: "出来ない",
-		opened: "できない"
-	},
-	{
-		closed: "下さい",
-		opened: "ください"
-	},
-	{
-		closed: "頂く",
-		opened: "いただく"
-	},
-	{
-		closed: "致す",
-		opened: "いたす"
-	},
-	{
-		closed: "何故",
-		opened: "なぜ"
-	},
-	{
-		closed: "為に",
-		opened: "ために"
-	},
-	{
-		closed: "時に",
-		opened: "ときに"
-	},
-	{
-		closed: "様に",
-		opened: "ように"
-	},
-	{
-		closed: "方が",
-		opened: "ほうが"
-	}
-];
-/**
-* Reports the first kanji occurrence of every pair the manuscript also writes in kana. Whether the
-* two spellings are a deliberate distinction is the author's call, so the finding is a warning.
-*/
-function build$3(pairs) {
-	return defineParsedRule(RULE_ID$5, MESSAGE, (manuscript, report) => {
-		for (const { closed, opened } of pairs) {
-			if (!manuscript.displayText.includes(opened)) continue;
-			const index = manuscript.displayText.indexOf(closed);
-			if (index === -1) continue;
-			report(displayRange(manuscript, index, index + closed.length), {
-				data: {
-					closed,
-					opened
-				},
-				severity: "warning"
-			});
-		}
-	});
-}
-const consistentKanjiOpeningRule = () => build$3(DEFAULT_PAIRS);
-function createConsistentKanjiOpeningRule(options = {}) {
-	if (options.pairs === void 0) return ManuscriptResult.succeed(consistentKanjiOpeningRule());
-	const pairs = v.safeParse(PairsSchema, options.pairs);
-	if (!pairs.success) return ManuscriptResult.fail({
-		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$5,
-		option: "pairs",
-		issues: ValidationIssue.from(pairs.issues)
-	});
-	return ManuscriptResult.succeed(build$3(pairs.output));
-}
-//#endregion
-//#region src/proofreading/rules/internal/mixed-width.ts
-/**
-* Builds a rule that fires when a manuscript uses both widths of one character class. Which width
-* is right is the author's decision, so the finding is a warning, and one finding at the first
-* halfwidth occurrence says everything a list of every mixed character would.
-*/
-function defineMixedWidthRule({ id, message, halfwidth, fullwidth }) {
-	return defineParsedRule(id, message, (manuscript, report) => {
-		const found = halfwidth.exec(manuscript.displayText);
-		const counterpart = fullwidth.exec(manuscript.displayText);
-		if (found === null || counterpart === null) return;
-		report(displayRange(manuscript, found.index, found.index + found[0].length), {
-			data: {
-				halfwidth: found[0],
-				fullwidth: counterpart[0]
-			},
-			severity: "warning"
-		});
-	});
-}
-//#endregion
-//#region src/proofreading/rules/consistent-latin-width.ts
-const consistentLatinWidthRule = () => defineMixedWidthRule({
-	id: "kg/consistent-latin-width",
-	message: "半角英字「{{ halfwidth }}」と全角英字「{{ fullwidth }}」が混在しています。作品内の方針を確認してください",
-	halfwidth: /[A-Za-z]/u,
-	fullwidth: /[Ａ-Ｚａ-ｚ]/u
-});
-//#endregion
-//#region src/proofreading/rules/consistent-numeral-width.ts
-const consistentNumeralWidthRule = () => defineMixedWidthRule({
-	id: "kg/consistent-numeral-width",
-	message: "半角数字「{{ halfwidth }}」と全角数字「{{ fullwidth }}」が混在しています。作品内の方針を確認してください",
-	halfwidth: /[0-9]/u,
-	fullwidth: /[０-９]/u
-});
-//#endregion
-//#region src/proofreading/rules/dash.ts
-const RULE_ID$4 = "kg/dash";
-const DEFAULT_PREFERRED = "―";
-const DashCharacterSchema = v.picklist([
-	"―",
-	"—",
-	"─"
-]);
-const DASH_LIKE_RUN = /[—–―─━﹣－-]+/gu;
-const EVEN_COUNT_MESSAGE = "連続するダッシュの数は偶数にしてください";
-function messageIdFor(run, preferred) {
-	if (run === "-") return void 0;
-	if (run !== preferred.repeat(run.length)) return "character";
-	return run.length % 2 === 1 ? "even-count" : void 0;
-}
-function build$2(preferred) {
-	const messages = {
-		character: `ダッシュには「${preferred}」を使ってください`,
-		"even-count": EVEN_COUNT_MESSAGE
-	};
-	return {
-		kind: "parsed",
-		meta: {
-			id: RULE_ID$4,
-			messages
-		},
-		check: (manuscript, context) => {
-			for (const line of splitDisplayLines(manuscript.displayText)) {
-				DASH_LIKE_RUN.lastIndex = 0;
-				let match = DASH_LIKE_RUN.exec(line.text);
-				while (match !== null) {
-					const run = match[0];
-					const messageId = messageIdFor(run, preferred);
-					if (messageId !== void 0) {
-						const start = line.start + match.index;
-						context.report({
-							range: displayRange(manuscript, start, start + run.length),
-							messageId
-						});
-					}
-					match = DASH_LIKE_RUN.exec(line.text);
-				}
-			}
-		}
-	};
-}
-const dashRule = () => build$2(DEFAULT_PREFERRED);
-function createDashRule(options = {}) {
-	if (options.preferred === void 0) return ManuscriptResult.succeed(dashRule());
-	const preferred = v.safeParse(DashCharacterSchema, options.preferred);
-	if (!preferred.success) return ManuscriptResult.fail({
-		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$4,
-		option: "preferred",
-		issues: ValidationIssue.from(preferred.issues)
-	});
-	return ManuscriptResult.succeed(build$2(preferred.output));
-}
-//#endregion
-//#region src/proofreading/rules/ellipsis-character.ts
-/**
-* Stand-ins for `…`. Runs of `。` and `・` are left to the rules that already count them, so one
-* substitute is never reported twice.
-*/
-const ellipsisCharacterRule = () => defineMatchRule({
-	id: "kg/ellipsis-character",
-	pattern: /\.{3,}|⋯+/gu,
-	message: "三点リーダーには「…」を使ってください"
-});
-//#endregion
-//#region src/proofreading/rules/even-ellipsis.ts
-const evenEllipsisRule = () => defineMatchRule({
-	id: "kg/even-ellipsis",
-	pattern: /…+/gu,
-	accept: (match) => match[0].length % 2 === 1,
-	message: "連続する三点リーダーの数は偶数にしてください"
-});
-//#endregion
-//#region src/proofreading/rules/fullwidth-japanese-punctuation.ts
-const RULE_ID$3 = "kg/fullwidth-japanese-punctuation";
-const MESSAGES$2 = {
-	"halfwidth-japanese-punctuation": "半角の「{{ character }}」があります。日本語の句読点・括弧・感嘆符・疑問符は全角にしてください",
-	"halfwidth-near-japanese": "日本語の前後に半角の「{{ character }}」があります。全角にすべきか確認してください"
-};
-const JAPANESE_CHARACTER = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}々〆ヵヶ]/u;
-const CHECKS = [
-	{
-		pattern: /[｡､｢｣]/gu,
-		messageId: "halfwidth-japanese-punctuation",
-		severity: "error",
-		requiresJapanese: false
-	},
-	{
-		pattern: /[!?]/gu,
-		messageId: "halfwidth-japanese-punctuation",
-		severity: "error",
-		requiresJapanese: true
-	},
-	{
-		pattern: /[,.()[\]{}]/gu,
-		messageId: "halfwidth-near-japanese",
-		severity: "warning",
-		requiresJapanese: true
-	}
-];
-function isBesideJapanese(text, index) {
-	const before = text[index - 1];
-	const after = text[index + 1];
-	return before !== void 0 && JAPANESE_CHARACTER.test(before) || after !== void 0 && JAPANESE_CHARACTER.test(after);
-}
-/**
-* A period inside a run of three or more is a stand-in for `…`, which `kg/ellipsis-character`
-* already reports.
-*/
-function isEllipsisSubstitute(text, index) {
-	if (text[index] !== ".") return false;
-	let start = index;
-	while (text[start - 1] === ".") start -= 1;
-	let end = index;
-	while (text[end + 1] === ".") end += 1;
-	return end - start + 1 >= 3;
-}
-const fullwidthJapanesePunctuationRule = () => ({
-	kind: "parsed",
-	meta: {
-		id: RULE_ID$3,
-		messages: MESSAGES$2
-	},
-	check: (manuscript, context) => {
-		for (const line of splitDisplayLines(manuscript.displayText)) for (const { pattern, messageId, severity, requiresJapanese } of CHECKS) for (const match of line.text.matchAll(pattern)) {
-			if (requiresJapanese && !isBesideJapanese(line.text, match.index)) continue;
-			if (isEllipsisSubstitute(line.text, match.index)) continue;
-			const start = line.start + match.index;
-			context.report({
-				range: displayRange(manuscript, start, start + match[0].length),
-				messageId,
-				data: { character: match[0] },
-				severity
-			});
-		}
-	}
-});
-//#endregion
-//#region src/proofreading/rules/max-arabic-numeral-digits.ts
-const RULE_ID$2 = "kg/max-arabic-numeral-digits";
-const DEFAULT_MAX_DIGITS = 2;
-const MaxDigitsSchema = v.pipe(v.number(), v.finite(), v.integer(), v.minValue(1));
-function build$1(maxDigits) {
-	return defineMatchRule({
-		id: RULE_ID$2,
-		pattern: /([0-9０-９]+)(?:[.．]([0-9０-９]+))?/gu,
-		accept: (match) => (match[1]?.length ?? 0) > maxDigits || (match[2]?.length ?? 0) > maxDigits,
-		message: `${maxDigits}桁を超えるアラビア数字が使われています`
-	});
-}
-const maxArabicNumeralDigitsRule = () => build$1(DEFAULT_MAX_DIGITS);
-function createMaxArabicNumeralDigitsRule(options = {}) {
-	if (options.maxDigits === void 0) return ManuscriptResult.succeed(maxArabicNumeralDigitsRule());
-	const maxDigits = v.safeParse(MaxDigitsSchema, options.maxDigits);
-	if (!maxDigits.success) return ManuscriptResult.fail({
-		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$2,
-		option: "maxDigits",
-		issues: ValidationIssue.from(maxDigits.issues)
-	});
-	return ManuscriptResult.succeed(build$1(maxDigits.output));
-}
-//#endregion
-//#region src/proofreading/rules/minus-before-number.ts
-const minusBeforeNumberRule = () => defineMatchRule({
-	id: "kg/minus-before-number",
-	pattern: /−(?![0-9０-９〇一二三四五六七八九十])/gu,
-	message: "マイナス記号の直後には数字が必要です"
-});
-//#endregion
-//#region src/proofreading/rules/no-consecutive-interpunct.ts
-const noConsecutiveInterpunctRule = () => defineMatchRule({
-	id: "kg/no-consecutive-interpunct",
-	pattern: /・・+/gu,
-	message: "中黒が連続しています"
-});
-//#endregion
-//#region src/proofreading/rules/no-consecutive-punctuation.ts
-const noConsecutivePunctuationRule = () => defineMatchRule({
-	id: "kg/no-consecutive-punctuation",
-	pattern: /。。+|、、+/gu,
-	message: "句読点が連続しています"
-});
-//#endregion
-//#region src/proofreading/rules/internal/decoration-line.ts
-const DECORATION_LINE = /^[＊*◆◇■□●○▽▼△▲☆★・…―─━ー\-=＝~～\s]+$/u;
-/**
-* A line made only of symbols and spaces: a scene break or a section marker rather than a
-* paragraph. Indentation rules skip these, because their layout is deliberate.
-*/
-function isDecorationLine(text) {
-	return DECORATION_LINE.test(text);
-}
-//#endregion
-//#region src/proofreading/rules/paragraph-opening.ts
-const RULE_ID$1 = "kg/paragraph-opening";
-const MESSAGES$1 = {
-	"leading-character": "段落の先頭には全角スペースまたは開き括弧が必要です",
-	"indent-width": "段落冒頭の字下げは全角スペース1字にしてください",
-	"unexpected-indent": "括弧から始まる段落を字下げすることはできません"
-};
-const OpeningBracketsSchema = v.pipe(v.string(), v.nonEmpty());
-/**
-* How a paragraph opens, judged as one decision: a paragraph that opens with a bracket carries no
-* indent, and prose carries exactly one ideographic space. The three findings are branches of that
-* one decision rather than separate rules, so a line can never collect two of them at once.
-*/
-function build(openingBrackets) {
-	return {
-		kind: "parsed",
-		meta: {
-			id: RULE_ID$1,
-			messages: MESSAGES$1
-		},
-		check: (manuscript, context) => {
-			const report = (start, end, messageId) => {
-				context.report({
-					range: displayRange(manuscript, start, end),
-					messageId
-				});
-			};
-			for (const line of splitDisplayLines(manuscript.displayText)) {
-				if (isDecorationLine(line.text)) continue;
-				const indent = leadingSpaces(line.text);
-				const opening = line.text[indent.length];
-				if (opening === void 0) continue;
-				if (openingBrackets.includes(opening)) {
-					if (indent !== "") report(line.start, line.start + indent.length, "unexpected-indent");
-				} else if (!line.text.startsWith("　")) {
-					const length = (line.text.codePointAt(0) ?? 0) > 65535 ? 2 : 1;
-					report(line.start, line.start + length, "leading-character");
-				} else if (indent.length !== 1) report(line.start, line.start + indent.length, "indent-width");
-			}
-		}
-	};
-}
-const paragraphOpeningRule = () => build(OPENING_BRACKETS);
-function createParagraphOpeningRule(options = {}) {
-	if (options.openingBrackets === void 0) return ManuscriptResult.succeed(paragraphOpeningRule());
-	const brackets = v.safeParse(OpeningBracketsSchema, options.openingBrackets);
-	if (!brackets.success) return ManuscriptResult.fail({
-		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$1,
-		option: "openingBrackets",
-		issues: ValidationIssue.from(brackets.issues)
-	});
-	return ManuscriptResult.succeed(build(brackets.output));
-}
-//#endregion
-//#region src/proofreading/rules/punctuation-before-closing-quote.ts
-const PATTERN = new RegExp(`[。、]+(?=[${characterClass(CLOSING_BRACKETS)}])`, "gu");
-const punctuationBeforeClosingQuoteRule = () => defineMatchRule({
-	id: "kg/punctuation-before-closing-quote",
-	pattern: PATTERN,
-	message: "閉じ括弧の直前に句読点を置くことはできません"
-});
-//#endregion
-//#region src/proofreading/rules/space-after-question-or-exclamation.ts
-const RULE_ID = "kg/space-after-question-or-exclamation";
-const MESSAGES = {
-	default: "感嘆符または疑問符の直後には全角スペースか閉じ括弧が必要です",
-	"space-width": "感嘆符または疑問符の直後の空白は全角スペース1字にしてください",
-	"before-closing-bracket": "閉じ括弧の直前に空白を置くことはできません"
-};
-/**
-* Checks the gap that follows every run of ！ or ？. A run at the end of a line or right before a
-* closing bracket needs no gap; anywhere else it takes exactly one ideographic space.
-*/
-const spaceAfterQuestionOrExclamationRule = () => ({
-	kind: "parsed",
-	meta: {
-		id: RULE_ID,
-		messages: MESSAGES
-	},
-	check: (manuscript, context) => {
-		const report = (start, end, messageId) => {
-			context.report({
-				range: displayRange(manuscript, start, end),
-				messageId
-			});
-		};
-		for (const line of splitDisplayLines(manuscript.displayText)) for (const spacing of questionOrExclamationSpacings(line.text)) switch (spacing.kind) {
-			case "valid": break;
-			case "missing":
-				report(line.start + spacing.marks.start, line.start + spacing.marks.end, "default");
-				break;
-			case "invalid-space":
-				report(line.start + spacing.gap.start, line.start + spacing.gap.end, "space-width");
-				break;
-			case "before-closing-bracket":
-				report(line.start + spacing.gap.start, line.start + spacing.gap.end, "before-closing-bracket");
-				break;
-			default: assertNever(spacing);
-		}
-	}
-});
-//#endregion
-//#region src/proofreading/rules/variant-character.ts
-/**
-* Mongolian free variation selectors, variation selectors, CJK compatibility ideographs, IVSes.
-*/
-function isVariantCharacter(character) {
-	const codePoint = character.codePointAt(0);
-	if (codePoint === void 0) return false;
-	return codePoint >= 6155 && codePoint <= 6157 || codePoint === 6159 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 194560 && codePoint <= 195103 || codePoint >= 917760 && codePoint <= 917999;
-}
-/**
-* Scans the source rather than the display text: notation removal must not hide a variant.
-*/
-const variantCharacterRule = () => defineParsedRule("kg/variant-character", "異体字または字形選択子が使われています", (manuscript, report) => {
-	for (const { index, segment } of graphemeSegmenter.segment(manuscript.source)) if (Array.from(segment).some(isVariantCharacter)) report(sourceRange(manuscript, {
-		start: index,
-		end: index + segment.length
-	}));
-});
-//#endregion
-//#region src/proofreading/rules/default-rules.ts
-/**
-* The built-in rule set at its default configuration. Infallible by construction: every rule is
-* built from constants, so there is no options error for a caller to handle.
-*
-* Rules whose answer depends on the work's own conventions — which width numerals take, whether a
-* word is written in kanji or kana — are exported individually instead of included here.
-*/
-function createDefaultProofreadingRules() {
-	return [
-		paragraphOpeningRule(),
-		punctuationBeforeClosingQuoteRule(),
-		spaceAfterQuestionOrExclamationRule(),
-		evenEllipsisRule(),
-		dashRule(),
-		ellipsisCharacterRule(),
-		noConsecutivePunctuationRule(),
-		noConsecutiveInterpunctRule(),
-		minusBeforeNumberRule(),
-		maxArabicNumeralDigitsRule(),
-		fullwidthJapanesePunctuationRule(),
-		variantCharacterRule()
-	];
-}
-//#endregion
-export { BoldAnnotation, ComposeError, ComposedAnnotationFragment, ComposedInlineItem, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, InlineMeasurement, InlineSpan, InvalidRuleOptions, ItalicAnnotation, LineBreakResult, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, NovelCompositionSettings, NovelFlowSettings, NovelLayout, NovelLine, NovelPage, NovelStage, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, RubyKind, RubyReading, SourcePosition, SourceRange, TextRange, ValidationIssue, VerticalTextPresentation, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createNovelComposer, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, logicalInlineMeasurer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, novelComposer, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };
+export { ComposeError, FontPreset, FontPresetId, FontSizePt, ManuscriptAppearanceSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NovelCompositionSettings, NovelFlowSettings, PaperSize, PaperSizeId, ParseError, composeManuscript, kakuyomuParser, novelComposer, parseManuscript, pixivParser, plainTextParser };