@sushichan044/kg-core 0.0.0 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,1500 @@
+import * as v from "valibot";
+//#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
+}) };
+const RubyAnnotation = { schema: readonlyObject({
+	kind: v.literal("ruby"),
+	range: ManuscriptRange.schema,
+	reading: v.string()
+}) };
+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 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));
+}
+const CONTRACT_MESSAGE = "parser output must contain consistent source, display, grapheme, and annotation ranges";
+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" });
+//#endregion
+//#region src/parser/internal/manuscript-draft.ts
+/**
+* Text appended in separate calls can still form one grapheme (a base character followed by a
+* combining mark). When that happens the trailing part is folded into the previous grapheme.
+*/
+function joinedPrefixLength(previous, text) {
+	const [first] = graphemeSegmenter.segment(previous + text);
+	return (first?.segment.length ?? previous.length) - previous.length;
+}
+function createManuscriptDraft(source) {
+	const displayParts = [];
+	const graphemes = [];
+	const annotations = [];
+	let displayLength = 0;
+	const append = (text, sourceStart) => {
+		const displayStart = displayLength;
+		let graphemeStart = graphemes.length;
+		let unsegmentedStart = 0;
+		displayParts.push(text);
+		const previous = graphemes.at(-1);
+		if (previous !== void 0 && text.length > 0) {
+			unsegmentedStart = joinedPrefixLength(previous.value, text);
+			if (unsegmentedStart > 0) {
+				previous.value += text.slice(0, unsegmentedStart);
+				previous.range.display.end += unsegmentedStart;
+				previous.range.source.end = sourceStart + unsegmentedStart;
+				graphemeStart -= 1;
+			}
+		}
+		for (const { index, segment } of graphemeSegmenter.segment(text.slice(unsegmentedStart))) {
+			const offset = unsegmentedStart + index;
+			const graphemeIndex = graphemes.length;
+			graphemes.push({
+				value: segment,
+				range: {
+					source: {
+						start: sourceStart + offset,
+						end: sourceStart + offset + segment.length
+					},
+					display: {
+						start: displayStart + offset,
+						end: displayStart + offset + segment.length
+					},
+					graphemes: {
+						start: graphemeIndex,
+						end: graphemeIndex + 1
+					}
+				}
+			});
+		}
+		displayLength += text.length;
+		return {
+			source: {
+				start: sourceStart,
+				end: sourceStart + text.length
+			},
+			display: {
+				start: displayStart,
+				end: displayLength
+			},
+			graphemes: {
+				start: Math.max(0, graphemeStart),
+				end: graphemes.length
+			}
+		};
+	};
+	return {
+		append,
+		annotate: (annotation) => {
+			annotations.push(annotation);
+		},
+		build: () => v.parse(ParsedManuscript.schema, {
+			source,
+			displayText: displayParts.join(""),
+			graphemes,
+			annotations
+		})
+	};
+}
+//#endregion
+//#region src/parser/plain-text-parser.ts
+/**
+* Treats the source verbatim: no notation, no annotations, display text equals source.
+*/
+const plainTextParser = {
+	id: "kg/plain-text",
+	parse: (source) => {
+		const draft = createManuscriptDraft(source);
+		draft.append(source, 0);
+		return ManuscriptResult.succeed(draft.build());
+	}
+};
+//#endregion
+//#region src/parser/parse-manuscript.ts
+function parseManuscript(source, options = {}) {
+	const parser = options.parser ?? plainTextParser;
+	const parserId = NamespacedId.parse(parser.id);
+	if (parserId === void 0) return ManuscriptResult.fail({
+		kind: "InvalidParserId",
+		parserId: parser.id
+	});
+	let raw;
+	try {
+		raw = parser.parse(source);
+	} catch (cause) {
+		return ManuscriptResult.fail({
+			kind: "ParserThrew",
+			parserId,
+			cause
+		});
+	}
+	const envelope = v.safeParse(ManuscriptResult.schema(ParsedManuscript.contractFor(source), Rejection.schema), raw);
+	if (!envelope.success) return ManuscriptResult.fail({
+		kind: "InvalidParserOutput",
+		parserId,
+		issues: ValidationIssue.from(envelope.issues)
+	});
+	const result = envelope.output;
+	return result.ok ? result : ManuscriptResult.fail({
+		kind: "ParserRejected",
+		parserId,
+		reason: result.error.reason
+	});
+}
+//#endregion
+//#region src/parser/internal/pixiv-notation.ts
+function trimContent(text, sourceStart) {
+	const trimmedStart = text.trimStart();
+	const leadingLength = text.length - trimmedStart.length;
+	return {
+		text: trimmedStart.trimEnd(),
+		sourceStart: sourceStart + leadingLength
+	};
+}
+/**
+* Tags never span lines, so a candidate closing delimiter past the line end does not count.
+*/
+function lineEnd(source, start) {
+	const lf = source.indexOf("\n", start);
+	const cr = source.indexOf("\r", start);
+	if (lf === -1) return cr === -1 ? source.length : cr;
+	if (cr === -1) return lf;
+	return Math.min(lf, cr);
+}
+function closingIndex(source, start, closing) {
+	const end = source.indexOf(closing, start);
+	return end !== -1 && end < lineEnd(source, start) ? end : void 0;
+}
+/**
+* Tag bodies hold literal text only; a nested bracket means this is not a well-formed tag.
+*/
+function isFlatContent(text) {
+	return text.length > 0 && !text.includes("[") && !text.includes("]");
+}
+function splitPair(body, bodySourceStart) {
+	const separator = body.indexOf(">");
+	if (separator === -1 || body.indexOf(">", separator + 1) !== -1) return void 0;
+	const left = trimContent(body.slice(0, separator), bodySourceStart);
+	const right = trimContent(body.slice(separator + 1), bodySourceStart + separator + 1);
+	return isFlatContent(left.text) && isFlatContent(right.text) ? [left, right] : void 0;
+}
+function parsePairTag(source, start, prefix) {
+	if (!source.startsWith(prefix, start)) return void 0;
+	const bodyStart = start + prefix.length;
+	const closing = closingIndex(source, bodyStart, "]]");
+	if (closing === void 0) return void 0;
+	const pair = splitPair(source.slice(bodyStart, closing), bodyStart);
+	if (pair === void 0) return void 0;
+	const [content, value] = pair;
+	if (prefix === "[[rb:") return {
+		end: closing + 2,
+		content,
+		annotation: {
+			kind: "ruby",
+			reading: value.text
+		}
+	};
+	if ([...graphemeSegmenter.segment(value.text)].length !== 1) return void 0;
+	return {
+		end: closing + 2,
+		content,
+		annotation: {
+			kind: "emphasis",
+			mark: value.text
+		}
+	};
+}
+function parseStyledTag(source, start, prefix) {
+	if (!source.startsWith(prefix, start)) return void 0;
+	const bodyStart = start + prefix.length;
+	const closing = closingIndex(source, bodyStart, "]");
+	if (closing === void 0) return void 0;
+	const content = {
+		text: source.slice(bodyStart, closing),
+		sourceStart: bodyStart
+	};
+	if (!isFlatContent(content.text)) return void 0;
+	return {
+		end: closing + 1,
+		content,
+		annotation: { kind: prefix === "[b:" ? "bold" : "italic" }
+	};
+}
+function parsePixivTag(source, start) {
+	return parsePairTag(source, start, "[[rb:") ?? parsePairTag(source, start, "[[emphasismark:") ?? parseStyledTag(source, start, "[b:") ?? parseStyledTag(source, start, "[i:");
+}
+/**
+* How far an unrecognised `[` run extends before it can be handed back to the reader as text.
+*/
+function literalEnd(source, start) {
+	const endOfLine = lineEnd(source, start);
+	const closing = source.indexOf("]", start + 1);
+	if (closing !== -1 && closing < endOfLine) return closing + 1;
+	return Math.max(start + 1, endOfLine);
+}
+//#endregion
+//#region src/parser/pixiv-parser.ts
+const PARSER_ID = NamespacedId.of("kg/pixiv");
+/**
+* Locates an unrecognised source span in display and grapheme coordinates for the warning.
+*/
+function spanRange(manuscript, span) {
+	const covered = manuscript.graphemes.filter(({ range }) => range.source.start < span.end && range.source.end > span.start);
+	const first = covered[0];
+	const last = covered.at(-1);
+	if (first === void 0 || last === void 0) return ManuscriptRange.of({
+		source: span,
+		display: {
+			start: 0,
+			end: 0
+		},
+		graphemes: {
+			start: 0,
+			end: 0
+		}
+	});
+	return ManuscriptRange.of({
+		source: span,
+		display: {
+			start: first.range.display.start,
+			end: last.range.display.end
+		},
+		graphemes: {
+			start: first.range.graphemes.start,
+			end: last.range.graphemes.end
+		}
+	});
+}
+function unrecognizedNotationWarning(source, manuscript, span, index) {
+	return ManuscriptDiagnostic.of({
+		source,
+		origin: {
+			kind: "parser",
+			id: PARSER_ID
+		},
+		severity: "warning",
+		code: `unrecognized-notation-${index}`,
+		message: "認識できない記法を原文として扱いました",
+		range: spanRange(manuscript, span)
+	});
+}
+/**
+* Understands Pixiv's ruby, bold, italic and emphasis-mark notation. Anything bracket-shaped that
+* does not parse is kept as literal text and reported as a warning rather than dropped.
+*/
+const pixivParser = {
+	id: PARSER_ID,
+	parse: (source) => {
+		const draft = createManuscriptDraft(source);
+		const unrecognized = [];
+		let index = 0;
+		while (index < source.length) {
+			if (source[index] !== "[") {
+				const nextTag = source.indexOf("[", index);
+				const end = nextTag === -1 ? source.length : nextTag;
+				draft.append(source.slice(index, end), index);
+				index = end;
+				continue;
+			}
+			const tag = parsePixivTag(source, index);
+			if (tag !== void 0) {
+				const range = draft.append(tag.content.text, tag.content.sourceStart);
+				draft.annotate({
+					...tag.annotation,
+					range: {
+						...range,
+						source: {
+							start: index,
+							end: tag.end
+						}
+					}
+				});
+				index = tag.end;
+				continue;
+			}
+			const end = literalEnd(source, index);
+			draft.append(source.slice(index, end), index);
+			unrecognized.push({
+				start: index,
+				end
+			});
+			index = end;
+		}
+		const manuscript = draft.build();
+		return ManuscriptResult.succeed(manuscript, unrecognized.map((span, order) => unrecognizedNotationWarning(source, manuscript, span, order)));
+	}
+};
+//#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;
+	const manuscript = v.safeParse(ParsedManuscript.schema, parsed);
+	if (!manuscript.success) return ManuscriptResult.fail({
+		kind: "InvalidManuscript",
+		issues: ValidationIssue.from(manuscript.issues)
+	});
+	const composerId = NamespacedId.parse(composer.id);
+	if (composerId === void 0) return ManuscriptResult.fail({
+		kind: "InvalidComposerId",
+		composerId: composer.id
+	});
+	const settings = v.safeParse(composer.settingsSchema, options.settings);
+	if (!settings.success) return ManuscriptResult.fail({
+		kind: "InvalidSettings",
+		composerId,
+		issues: ValidationIssue.from(settings.issues)
+	});
+	let raw;
+	try {
+		raw = composer.compose(manuscript.output, settings.output);
+	} catch (cause) {
+		return ManuscriptResult.fail({
+			kind: "ComposerThrew",
+			composerId,
+			cause
+		});
+	}
+	const envelope = v.safeParse(ManuscriptResult.schema(composer.layoutSchema, Rejection.schema), raw);
+	if (!envelope.success) return ManuscriptResult.fail({
+		kind: "InvalidComposerOutput",
+		composerId,
+		issues: ValidationIssue.from(envelope.issues)
+	});
+	const result = envelope.output;
+	if (!result.ok) return ManuscriptResult.fail({
+		kind: "ComposerRejected",
+		composerId,
+		reason: result.error.reason
+	});
+	return ManuscriptResult.succeed({
+		composerId,
+		parsed: manuscript.output,
+		settings: settings.output,
+		layout: result.value
+	}, result.warnings);
+}
+//#endregion
+//#region src/composer/grid-settings.ts
+const RANGES = {
+	charsPerLine: {
+		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 GridSettings = {
+	schema: readonlyObject({
+		charsPerLine: boundedCount(RANGES.charsPerLine),
+		linesPerStage: boundedCount(RANGES.linesPerStage),
+		stagesPerPage: boundedCount(RANGES.stagesPerPage)
+	}),
+	ranges: RANGES,
+	defaults: {
+		charsPerLine: 27,
+		linesPerStage: 23,
+		stagesPerPage: 2
+	}
+};
+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: (grid) => Math.max(0, grid.linesPerStage - 1),
+	/**
+	* Page offsets must leave at least one usable line on the page, after stage offsets apply.
+	*/
+	maxPageTotal: (grid, stage) => Math.max(0, (grid.linesPerStage - LineOffset.total(stage)) * grid.stagesPerPage - 1)
+};
+//#endregion
+//#region src/composer/composition-settings.ts
+const ManuscriptCompositionSettingsSchema = v.pipe(readonlyObject({
+	grid: GridSettings.schema,
+	offsets: ManuscriptOffsets.schema,
+	appearance: ManuscriptAppearanceSettings.schema
+}), v.check(({ grid, offsets }) => LineOffset.total(offsets.stage) <= ManuscriptOffsets.maxStageTotal(grid) && LineOffset.total(offsets.page) <= ManuscriptOffsets.maxPageTotal(grid, offsets.stage), "page or stage offsets leave no usable manuscript lines"));
+const ManuscriptCompositionSettings = {
+	schema: ManuscriptCompositionSettingsSchema,
+	defaults: {
+		grid: GridSettings.defaults,
+		offsets: ManuscriptOffsets.defaults,
+		appearance: ManuscriptAppearanceSettings.defaults
+	},
+	is: (value) => v.is(ManuscriptCompositionSettingsSchema, value)
+};
+const CompositionStatistics = { schema: readonlyObject({
+	chars: nonNegativeInteger(),
+	sourceLines: nonNegativeInteger(),
+	pages: nonNegativeInteger()
+}) };
+const GridCell = {
+	schema: readonlyObject({
+		value: v.nullable(v.string()),
+		range: v.nullable(ManuscriptRange.schema),
+		annotations: readonlyArray(ManuscriptAnnotation.schema)
+	}),
+	empty: () => ({
+		value: null,
+		range: null,
+		annotations: []
+	})
+};
+const GridLine = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		cells: readonlyArray(GridCell.schema)
+	}),
+	of: (cells) => ({
+		cells,
+		range: ManuscriptRange.merge(cells.map(({ range }) => range))
+	}),
+	/**
+	* Pads with empty cells so every line in a stage has the same length.
+	*/
+	padded: (cells, charsPerLine) => GridLine.of([...cells, ...Array.from({ length: Math.max(0, charsPerLine - cells.length) }, GridCell.empty)])
+};
+const GridStage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		lines: readonlyArray(GridLine.schema)
+	}),
+	of: (lines) => ({
+		lines,
+		range: ManuscriptRange.merge(lines.map(({ range }) => range))
+	})
+};
+const GridPage = {
+	schema: readonlyObject({
+		range: v.nullable(ManuscriptRange.schema),
+		stages: readonlyArray(GridStage.schema)
+	}),
+	of: (stages) => ({
+		stages,
+		range: ManuscriptRange.merge(stages.map(({ range }) => range))
+	})
+};
+//#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,
+	gridWidthMm: nonNegativeLength(),
+	gridHeightMm: 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 gridHeightInCells(grid) {
+	return grid.stagesPerPage * grid.charsPerLine + STAGE_GAP_CELLS * (grid.stagesPerPage - 1);
+}
+/**
+* Every vertical line side by side, plus the gap between adjacent lines.
+*/
+function gridWidthInCells(grid) {
+	return grid.linesPerStage + LINE_GAP_CELLS * (grid.linesPerStage - 1);
+}
+const ManuscriptGeometry = {
+	schema: ManuscriptGeometrySchema,
+	of: (grid, appearance) => {
+		const paper = PaperSize.of(appearance.paperSize);
+		const cellSizeMm = ptToMm(appearance.fontSizePt);
+		const gridWidthMm = gridWidthInCells(grid) * cellSizeMm;
+		const gridHeightMm = gridHeightInCells(grid) * cellSizeMm;
+		const marginInlineMm = (paper.widthMm - gridWidthMm) / 2;
+		const marginBlockMm = (paper.heightMm - gridHeightMm) / 2;
+		return {
+			paperWidthMm: paper.widthMm,
+			paperHeightMm: paper.heightMm,
+			cellSizeMm,
+			lineGapMm: LINE_GAP_CELLS * cellSizeMm,
+			fontSizePt: appearance.fontSizePt,
+			gridWidthMm,
+			gridHeightMm,
+			marginInlineMm,
+			marginBlockMm,
+			fitsPaper: marginInlineMm >= 0 && marginBlockMm >= 0
+		};
+	},
+	/**
+	* The largest step-aligned point size whose grid still fits the paper, clamped to the range.
+	*/
+	maxFontSizePt: (grid, paperSizeId) => {
+		const paper = PaperSize.of(paperSizeId);
+		const maxCellSizeMm = Math.min(paper.widthMm / gridWidthInCells(grid), paper.heightMm / gridHeightInCells(grid));
+		const steps = Math.floor(mmToPt(maxCellSizeMm) / FontSizePt.range.step + 1e-9);
+		const aligned = Math.round(steps * FontSizePt.range.step * 1e3) / 1e3;
+		return Math.min(FontSizePt.range.max, Math.max(FontSizePt.range.min, aligned));
+	}
+};
+const ManuscriptGridLayout = { schema: readonlyObject({
+	pages: readonlyArray(GridPage.schema),
+	geometry: ManuscriptGeometry.schema,
+	stats: CompositionStatistics.schema
+}) };
+//#endregion
+//#region src/composer/grid-composer.ts
+const COMPOSER_ID = NamespacedId.of("kg/grid");
+/**
+* Splits display graphemes on line breaks. A trailing break does not create an empty last line.
+*/
+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 toCells(sourceLine, annotations) {
+	return sourceLine.map((grapheme) => ({
+		value: grapheme.value,
+		range: grapheme.range,
+		annotations: ManuscriptAnnotation.overlapping(annotations, grapheme.range)
+	}));
+}
+/**
+* Wraps one source line across as many grid lines as its length requires.
+*/
+function wrapLine(cells, charsPerLine) {
+	if (cells.length === 0) return [GridLine.padded([], charsPerLine)];
+	return Array.from({ length: Math.ceil(cells.length / charsPerLine) }, (_unused, index) => GridLine.padded(cells.slice(index * charsPerLine, (index + 1) * charsPerLine), charsPerLine));
+}
+function blankLines(count, charsPerLine) {
+	return Array.from({ length: count }, () => GridLine.padded([], charsPerLine));
+}
+/**
+* Walks every line position on every page in reading order, handing out content lines only where
+* the stage and page offsets leave room. Always emits at least one page.
+*/
+function buildPages(contentLines, settings) {
+	const { charsPerLine, linesPerStage, stagesPerPage } = settings.grid;
+	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(GridLine.padded([], charsPerLine));
+					continue;
+				}
+				lines.push(next);
+				contentIndex += 1;
+			}
+			stages.push(GridStage.of(lines));
+		}
+		pages.push(GridPage.of(stages));
+	}
+	return pages;
+}
+function composeGrid(manuscript, settings) {
+	const { charsPerLine } = settings.grid;
+	const sourceLines = displayedLines(manuscript.graphemes);
+	const cellLines = sourceLines.map((line) => toCells(line, manuscript.annotations));
+	const manuscriptLines = cellLines.flatMap((cells) => wrapLine(cells, charsPerLine));
+	const pages = buildPages([
+		...blankLines(settings.offsets.document.leading, charsPerLine),
+		...manuscriptLines,
+		...blankLines(settings.offsets.document.trailing, charsPerLine)
+	], settings);
+	return ManuscriptResult.succeed({
+		pages,
+		geometry: ManuscriptGeometry.of(settings.grid, settings.appearance),
+		stats: {
+			chars: cellLines.reduce((total, cells) => total + cells.length, 0),
+			sourceLines: sourceLines.length,
+			pages: pages.length
+		}
+	});
+}
+/**
+* Places text on Japanese manuscript paper: vertical lines grouped into stages, stages into pages.
+* Settings arrive already validated by {@link composeManuscript}, so this never rejects.
+*/
+const manuscriptGridComposer = {
+	id: COMPOSER_ID,
+	settingsSchema: ManuscriptCompositionSettings.schema,
+	layoutSchema: ManuscriptGridLayout.schema,
+	compose: composeGrid
+};
+//#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()))
+}) };
+//#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: "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) => {
+				context.report({
+					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/even-dash.ts
+const evenDashRule = () => defineMatchRule({
+	id: "kg/even-dash",
+	pattern: /―+/gu,
+	accept: (match) => match[0].length % 2 === 1,
+	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/max-arabic-numeral-digits.ts
+const RULE_ID$1 = "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$1,
+		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$1,
+		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-choonpu.ts
+const noConsecutiveChoonpuRule = () => defineMatchRule({
+	id: "kg/no-consecutive-choonpu",
+	pattern: /ーー+/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/paragraph-leading-character.ts
+const RULE_ID = "kg/paragraph-leading-character";
+const MESSAGE = "段落の先頭には全角スペースまたは開き括弧が必要です";
+const DEFAULT_ALLOWED_CHARACTERS = "　「『〖〈《（(“\"‘'［[〔｛{＜<";
+const AllowedCharactersSchema = v.pipe(v.string(), v.nonEmpty());
+function build(allowedCharacters) {
+	return defineParsedRule(RULE_ID, MESSAGE, (manuscript, report) => {
+		for (const line of splitDisplayLines(manuscript.displayText)) {
+			const leading = line.text[0];
+			if (leading === void 0 || allowedCharacters.includes(leading)) continue;
+			const length = (line.text.codePointAt(0) ?? 0) > 65535 ? 2 : 1;
+			report(displayRange(manuscript, line.start, line.start + length));
+		}
+	});
+}
+const paragraphLeadingCharacterRule = () => build(DEFAULT_ALLOWED_CHARACTERS);
+function createParagraphLeadingCharacterRule(options = {}) {
+	if (options.allowedCharacters === void 0) return ManuscriptResult.succeed(paragraphLeadingCharacterRule());
+	const allowed = v.safeParse(AllowedCharactersSchema, options.allowedCharacters);
+	if (!allowed.success) return ManuscriptResult.fail({
+		kind: "InvalidRuleOptions",
+		ruleId: RULE_ID,
+		option: "allowedCharacters",
+		issues: ValidationIssue.from(allowed.issues)
+	});
+	return ManuscriptResult.succeed(build(allowed.output));
+}
+//#endregion
+//#region src/proofreading/rules/punctuation-before-closing-quote.ts
+const punctuationBeforeClosingQuoteRule = () => defineMatchRule({
+	id: "kg/punctuation-before-closing-quote",
+	pattern: /[。、]+(?=[」』〗〉》）)”"’'］\]〕｝}＞>])/gu,
+	message: "閉じ括弧の直前に句読点を置くことはできません"
+});
+//#endregion
+//#region src/proofreading/rules/space-after-question-or-exclamation.ts
+const spaceAfterQuestionOrExclamationRule = () => defineMatchRule({
+	id: "kg/space-after-question-or-exclamation",
+	pattern: /[？！](?![ 　？！」』〗〉》）)”"’'］\]〕｝}＞>]|$)/gu,
+	message: "感嘆符または疑問符の直後には空白か閉じ括弧が必要です"
+});
+//#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.
+*/
+function createDefaultProofreadingRules() {
+	return [
+		paragraphLeadingCharacterRule(),
+		punctuationBeforeClosingQuoteRule(),
+		spaceAfterQuestionOrExclamationRule(),
+		evenEllipsisRule(),
+		evenDashRule(),
+		noConsecutivePunctuationRule(),
+		noConsecutiveInterpunctRule(),
+		noConsecutiveChoonpuRule(),
+		minusBeforeNumberRule(),
+		maxArabicNumeralDigitsRule(),
+		variantCharacterRule()
+	];
+}
+//#endregion
+export { BoldAnnotation, ComposeError, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, GridCell, GridLine, GridPage, GridSettings, GridStage, InvalidRuleOptions, ItalicAnnotation, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptCompositionSettings, ManuscriptDiagnostic, ManuscriptGeometry, ManuscriptGridLayout, ManuscriptOffsets, ManuscriptRange, ManuscriptResult, NamespacedId, PaperSize, PaperSizeId, ParseError, ParsedGrapheme, ParsedManuscript, ProofreadError, ProofreadingReport, ProofreadingRuleMeta, Rejection, RubyAnnotation, SourcePosition, SourceRange, TextRange, ValidationIssue, assertNever, composeManuscript, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphLeadingCharacterRule, evenDashRule, evenEllipsisRule, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveChoonpuRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphLeadingCharacterRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };