@sushichan044/kg-core 0.6.5 → 0.8.0

package/dist/lint.mjs

@@ -0,0 +1,812 @@
+import { a as characterClass, c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, i as OPENING_BRACKETS, l as ManuscriptDiagnostic, m as readonlyArray, n as leadingSpaces, o as graphemeSegmenter, r as CLOSING_BRACKETS, s as ValidationIssue, t as questionOrExclamationSpacings, u as DiagnosticSeverity } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
+import { n as assertNever, t as describeCause } from "./describe-cause-BV8mZ3Um.mjs";
+import * as v from "valibot";
+//#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
+/**
+* Halfwidth and fullwidth Latin letters (半角英字 and 全角英字) in one work. In vertical writing the two
+* are set differently — a fullwidth letter stands upright on its own em, a halfwidth one joins a
+* run that may turn sideways — so mixing them is 表記ゆれ the reader can see. Which one a work uses is
+* its own choice, hence a warning.
+*/
+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
+/**
+* Halfwidth and fullwidth digits (半角数字 and 全角数字) in one work. A fullwidth digit stands upright on
+* its own em; a halfwidth pair sets as 縦中横 inside one. Mixing them is 表記ゆれ, but which one a work
+* uses is its own choice, hence a warning.
+*/
+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;
+}
+/**
+* The dash a novel sets is the 2倍ダッシュ: two copies of one character read as a single rule two ems
+* long. That is why an odd run is a finding — half a dash is left over — and why the characters
+* must match, since only a repeat of the same character joins without a seam. JLReq classes the
+* dash as 分離禁止文字 (cl-08) for the same reason: the pair must not be split across lines.
+*/
+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 the ellipsis (三点リーダー) `…`. Only the real character is set on its own em and pairs
+* into a 2倍リーダ; a run of ASCII periods is neither. 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
+/**
+* The ellipsis a novel sets is the 2倍リーダ: two copies of `…` read as one mark six dots long. An odd
+* run leaves half of it, the same way an odd dash run does.
+*/
+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;
+}
+/**
+* Halfwidth punctuation (約物) where Japanese prose calls for the fullwidth form. Japanese
+* punctuation is designed to occupy one em, and the composer's spacing rules are stated in those
+* terms, so a halfwidth form neither lands on the grid nor picks up the spacing its character class
+* calls for.
+*
+* The three checks differ in how much the surroundings decide the answer, which is why only the
+* first is decisive on its own.
+*/
+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));
+/**
+* Arabic numerals in vertical writing (縦組). A short run is set as 縦中横 (JLReq 3.2.5) and stays
+* upright inside one em, but a longer one has nowhere to go: it either turns the line sideways or
+* breaks across it. The usual limit is two digits, past which a novel spells the number in kanji.
+*/
+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
+/**
+* A minus sign (U+2212, JLReq 演算記号) with no number after it. It is almost always a mistyped dash or
+* prolonged sound mark, which look alike but belong to different character classes and so are
+* spaced and broken differently.
+*/
+const minusBeforeNumberRule = () => defineMatchRule({
+	id: "kg/minus-before-number",
+	pattern: /−(?![0-9０-９〇一二三四五六七八九十])/gu,
+	message: "マイナス記号の直後には数字が必要です"
+});
+//#endregion
+//#region src/proofreading/rules/no-consecutive-interpunct.ts
+/**
+* A repeated interpunct (中黒, JLReq 中点類 cl-05). The interpunct separates items; repeating it is
+* almost always a stand-in for an ellipsis, which `kg/ellipsis-character` names properly.
+*/
+const noConsecutiveInterpunctRule = () => defineMatchRule({
+	id: "kg/no-consecutive-interpunct",
+	pattern: /・・+/gu,
+	message: "中黒が連続しています"
+});
+//#endregion
+//#region src/proofreading/rules/no-consecutive-punctuation.ts
+/**
+* A repeated full stop or comma (句読点 — JLReq 句点類 cl-06 and 読点類 cl-07). Each ends its clause once,
+* so a run of them is not punctuation at all: it is a sentence trailing off, which Japanese prose
+* writes with `…`.
+*/
+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());
+/**
+* Paragraph indentation (字下げ, JLReq 3.5.1). Japanese prose opens a paragraph with exactly one
+* ideographic space (和字間隔), and a paragraph opening with a bracket (始め括弧類) carries none, because
+* the bracket is already set on a half em and reads as the indent itself.
+*
+* 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");
+/**
+* A full stop or comma immediately before a closing bracket (終わり括弧類). The bracket already closes
+* the quotation, and both characters are set on a half em, so the pair reads as a gap in the line
+* rather than as punctuation. Japanese practice drops the punctuation and keeps the bracket.
+*/
+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": "閉じ括弧の直前に空白を置くことはできません"
+};
+/**
+* The gap that follows every run of ！ or ？ (区切り約物, JLReq 3.1.6). A dividing punctuation mark ends a
+* sentence without a full stop, so a full em of white stands in for the one a 句点 would have
+* carried. A run at the end of a line or right before a closing bracket is already separated from
+* what follows and 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;
+}
+/**
+* Variant forms of a character (異体字) and the selectors that request them (字形選択子 / IVS). Whether
+* such a form survives depends on the font and the platform, so a manuscript that relies on one
+* will not read the same everywhere it is published.
+*
+* 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 { InvalidRuleOptions, ProofreadError, ProofreadingRuleMeta, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, maxArabicNumeralDigitsRule, minusBeforeNumberRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphOpeningRule, proofreadManuscript, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };