@sushichan044/kg-core 0.4.0 → 0.5.0

package/README.md

@@ -24,12 +24,13 @@ import {
   manuscriptGridComposer,
   ParseError,
   parseManuscript,
+  kakuyomuParser,
   pixivParser,
   ProofreadError,
   proofreadManuscript,
 } from "@sushichan044/kg-core";
 
-const parsed = parseManuscript(source, { parser: pixivParser });
+const parsed = parseManuscript(source, { parser: kakuyomuParser });
 if (!parsed.ok) throw new Error(ParseError.describe(parsed.error));
 
 const composed = composeManuscript(parsed.value, {
@@ -46,10 +47,10 @@ if (!proofread.ok) throw new Error(ProofreadError.describe(proofread.error));
 const diagnostics = [...parsed.warnings, ...proofread.value];
 ```
 
-`parseManuscript` uses `plainTextParser` when no parser is supplied. The Pixiv
-parser normalizes ruby, bold, italic, and emphasis notation into a closed
-annotation union. Malformed or unknown notation remains visible and produces a
-parser warning.
+`parseManuscript` uses `plainTextParser` when no parser is supplied. The built-in
+`pixivParser` normalizes ruby, bold, italic, and emphasis notation; `kakuyomuParser`
+normalizes Kakuyomu ruby and emphasis marks. Malformed or unknown notation remains
+visible and produces a parser warning.
 
 `composeManuscript` requires a composer. The built-in grid composer produces a
 self-contained snapshot containing the parsed manuscript, accepted settings,
@@ -62,7 +63,8 @@ element has source, display, and grapheme ranges; empty placement elements use
 Parsers implement `ManuscriptParser`. Composers implement `ManuscriptComposer`
 and provide Valibot schemas for their settings and layout. Proofreading rules
 carry `kind: "parsed"` or `kind: "composed"` to declare which manuscript they
-need, and report findings through `context.report`.
+need, and report findings through `context.report`. A report may name a
+`severity`; omitting it means `error`.
 
 A plugin signals its own failure with a `Rejection` — a plain reason string.
 Core turns that into a variant of the stage's error union, so plugins never
@@ -87,9 +89,40 @@ Grapheme ranges index the normalized grapheme array. Diagnostics include
 one-based source line and column positions, so renderers do not need to search
 or recalculate locations.
 
-The default proofreading rules report common Japanese novel-style issues and
-Unicode variation sequences. Diagnostics do not modify the source and do not
-contain automatic fixes.
+## Proofreading rules
+
+`createDefaultProofreadingRules()` returns the rules whose answer does not
+depend on the work: how a paragraph opens and how far it is indented,
+punctuation before a closing bracket, spacing after `！` and `？`, ellipsis and
+dash forms and counts, repeated punctuation, repeated interpuncts and choonpu, a
+minus sign that no number follows, halfwidth Japanese punctuation, Arabic
+numeral length, and Unicode variation sequences.
+
+Rules that depend on the work's own conventions are exported individually and
+report `warning` instead of `error`, so a caller opts into them:
+
+```ts
+import {
+  consistentKanjiOpeningRule,
+  consistentLatinWidthRule,
+  consistentNumeralWidthRule,
+  createConsistentKanjiOpeningRule,
+  createDefaultProofreadingRules,
+} from "@sushichan044/kg-core";
+
+const rules = [
+  ...createDefaultProofreadingRules(),
+  consistentNumeralWidthRule(),
+  consistentLatinWidthRule(),
+  consistentKanjiOpeningRule(),
+];
+```
+
+`createConsistentKanjiOpeningRule({ pairs })` replaces the built-in kanji and
+kana pairs; like every configurable rule it returns a `ManuscriptResult` and
+fails with `InvalidRuleOptions` rather than dropping bad options.
+
+Diagnostics do not modify the source and do not contain automatic fixes.
 
 ## Browser support
 

package/dist/index.d.mts

@@ -3330,6 +3330,13 @@ declare const ParsedGrapheme: {
   }>]>;
 };
 //#endregion
+//#region src/parser/kakuyomu-parser.d.ts
+/**
+ * Understands Kakuyomu's ruby and emphasis-mark notation. Invalid notation stays literal so source
+ * ranges remain inspectable, while clear notation candidates receive a parser warning.
+ */
+declare const kakuyomuParser: ManuscriptParser;
+//#endregion
 //#region src/parser/pixiv-parser.d.ts
 /**
  * Understands Pixiv's ruby, bold, italic and emphasis-mark notation. Anything bracket-shaped that
@@ -14425,6 +14432,10 @@ declare const ProofreadingReportSchema: v.SchemaWithPipe<readonly [v.StrictObjec
   readonly data: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<{
     [x: string]: string | number;
   }>]>, undefined>;
+  /**
+   * Omitted means `error`: a rule that says nothing is claiming it found a real defect.
+   */
+  readonly severity: v.OptionalSchema<v.PicklistSchema<["warning", "error"], undefined>, undefined>;
 }, undefined>, v.ReadonlyAction<{
   readonly range: Readonly<{
     source: Readonly<{
@@ -14444,6 +14455,7 @@ declare const ProofreadingReportSchema: v.SchemaWithPipe<readonly [v.StrictObjec
   data?: Readonly<{
     [x: string]: string | number;
   }> | undefined;
+  severity?: "error" | "warning" | undefined;
 }>]>;
 /**
  * What a rule hands back for one finding. The rule names a message it declared rather than
@@ -14510,6 +14522,10 @@ declare const ProofreadingReport: {
     readonly data: v.OptionalSchema<v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, undefined>, v.ReadonlyAction<{
       [x: string]: string | number;
     }>]>, undefined>;
+    /**
+     * Omitted means `error`: a rule that says nothing is claiming it found a real defect.
+     */
+    readonly severity: v.OptionalSchema<v.PicklistSchema<["warning", "error"], undefined>, undefined>;
   }, undefined>, v.ReadonlyAction<{
     readonly range: Readonly<{
       source: Readonly<{
@@ -14529,6 +14545,7 @@ declare const ProofreadingReport: {
     data?: Readonly<{
       [x: string]: string | number;
     }> | undefined;
+    severity?: "error" | "warning" | undefined;
   }>]>;
 };
 //#endregion
@@ -14613,19 +14630,66 @@ declare function proofreadManuscript(manuscript: ParsedManuscript, options: Proo
  */
 declare function proofreadManuscript<TComposed extends ComposedManuscript>(manuscript: TComposed, options: ProofreadOptions<ParsedProofreadingRule | ComposedProofreadingRule<TComposed>>): ProofreadOutcome;
 //#endregion
+//#region src/proofreading/rules/consistent-kanji-opening.d.ts
+declare const KanjiOpeningPairSchema: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly closed: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
+  readonly opened: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>]>;
+}, undefined>, v.ReadonlyAction<{
+  closed: string;
+  opened: string;
+}>]>, v.CheckAction<Readonly<{
+  closed: string;
+  opened: string;
+}>, "a pair must hold two different spellings">]>;
+/**
+ * A word written in kanji, paired with the kana form of the same word.
+ */
+type KanjiOpeningPair = v.InferOutput<typeof KanjiOpeningPairSchema>;
+type ConsistentKanjiOpeningOptions = Readonly<{
+  pairs?: readonly KanjiOpeningPair[];
+}>;
+declare const consistentKanjiOpeningRule: () => ParsedProofreadingRule;
+declare function createConsistentKanjiOpeningRule(options?: ConsistentKanjiOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+//#endregion
+//#region src/proofreading/rules/consistent-latin-width.d.ts
+declare const consistentLatinWidthRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/consistent-numeral-width.d.ts
+declare const consistentNumeralWidthRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/dash-character.d.ts
+/**
+ * Stand-ins for `―`. Repeated `ー` belongs to `kg/no-consecutive-choonpu` and `−` to
+ * `kg/minus-before-number`, so neither is reported twice.
+ */
+declare const dashCharacterRule: () => ParsedProofreadingRule;
+//#endregion
 //#region src/proofreading/rules/default-rules.d.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.
  */
 declare function createDefaultProofreadingRules(): readonly ParsedProofreadingRule[];
 //#endregion
+//#region src/proofreading/rules/ellipsis-character.d.ts
+/**
+ * Stand-ins for `…`. Runs of `。` and `・` are left to the rules that already count them, so one
+ * substitute is never reported twice.
+ */
+declare const ellipsisCharacterRule: () => ParsedProofreadingRule;
+//#endregion
 //#region src/proofreading/rules/even-dash.d.ts
 declare const evenDashRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/even-ellipsis.d.ts
 declare const evenEllipsisRule: () => ParsedProofreadingRule;
 //#endregion
+//#region src/proofreading/rules/fullwidth-japanese-punctuation.d.ts
+declare const fullwidthJapanesePunctuationRule: () => ParsedProofreadingRule;
+//#endregion
 //#region src/proofreading/rules/max-arabic-numeral-digits.d.ts
 type MaxArabicNumeralDigitsOptions = Readonly<{
   maxDigits?: number;
@@ -14645,17 +14709,21 @@ declare const noConsecutiveInterpunctRule: () => ParsedProofreadingRule;
 //#region src/proofreading/rules/no-consecutive-punctuation.d.ts
 declare const noConsecutivePunctuationRule: () => ParsedProofreadingRule;
 //#endregion
-//#region src/proofreading/rules/paragraph-leading-character.d.ts
-type ParagraphLeadingCharacterOptions = Readonly<{
-  allowedCharacters?: string;
+//#region src/proofreading/rules/paragraph-opening.d.ts
+type ParagraphOpeningOptions = Readonly<{
+  openingBrackets?: string;
 }>;
-declare const paragraphLeadingCharacterRule: () => ParsedProofreadingRule;
-declare function createParagraphLeadingCharacterRule(options?: ParagraphLeadingCharacterOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+declare const paragraphOpeningRule: () => ParsedProofreadingRule;
+declare function createParagraphOpeningRule(options?: ParagraphOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
 //#endregion
 //#region src/proofreading/rules/punctuation-before-closing-quote.d.ts
 declare const punctuationBeforeClosingQuoteRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/space-after-question-or-exclamation.d.ts
+/**
+ * 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.
+ */
 declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/variant-character.d.ts
@@ -14664,4 +14732,4 @@ declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
  */
 declare const variantCharacterRule: () => ParsedProofreadingRule;
 //#endregion
-export { BoldAnnotation, ComposeError, type ComposeManuscriptOptions, type ComposedManuscript, type ComposedProofreadingRule, CompositionStatistics, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, GridCell, type GridComposedManuscript, GridLine, GridPage, GridSettings, GridStage, InvalidRuleOptions, ItalicAnnotation, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, type ManuscriptComposer, ManuscriptCompositionSettings, ManuscriptDiagnostic, type ManuscriptDiagnosticInput, ManuscriptGeometry, ManuscriptGridLayout, ManuscriptOffsets, type ManuscriptParser, ManuscriptRange, type ManuscriptRangeInput, ManuscriptResult, type MaxArabicNumeralDigitsOptions, NamespacedId, PaperSize, PaperSizeId, type ParagraphLeadingCharacterOptions, ParseError, type ParseManuscriptOptions, ParsedGrapheme, ParsedManuscript, type ParsedProofreadingRule, ProofreadError, type ProofreadOptions, ProofreadingReport, type ProofreadingRule, type ProofreadingRuleContext, type ProofreadingRuleMessages, 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 };
+export { BoldAnnotation, ComposeError, type ComposeManuscriptOptions, type ComposedManuscript, type ComposedProofreadingRule, CompositionStatistics, type ConsistentKanjiOpeningOptions, DiagnosticOrigin, DiagnosticSeverity, DisplayRange, EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, GraphemeRange, GridCell, type GridComposedManuscript, GridLine, GridPage, GridSettings, GridStage, InvalidRuleOptions, ItalicAnnotation, type KanjiOpeningPair, LineOffset, ManuscriptAnnotation, ManuscriptAppearanceSettings, type ManuscriptComposer, ManuscriptCompositionSettings, ManuscriptDiagnostic, type ManuscriptDiagnosticInput, ManuscriptGeometry, ManuscriptGridLayout, ManuscriptOffsets, type ManuscriptParser, ManuscriptRange, type ManuscriptRangeInput, ManuscriptResult, type MaxArabicNumeralDigitsOptions, NamespacedId, PaperSize, PaperSizeId, type ParagraphOpeningOptions, ParseError, type ParseManuscriptOptions, ParsedGrapheme, ParsedManuscript, type ParsedProofreadingRule, ProofreadError, type ProofreadOptions, ProofreadingReport, type ProofreadingRule, type ProofreadingRuleContext, type ProofreadingRuleMessages, ProofreadingRuleMeta, Rejection, RubyAnnotation, SourcePosition, SourceRange, TextRange, ValidationIssue, assertNever, composeManuscript, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashCharacterRule, ellipsisCharacterRule, evenDashRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveChoonpuRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };

package/dist/index.mjs

@@ -513,17 +513,9 @@ function parseManuscript(source, options = {}) {
 	});
 }
 //#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
-	};
-}
+//#region src/parser/internal/line-end.ts
 /**
-* Tags never span lines, so a candidate closing delimiter past the line end does not count.
+* Returns the first line terminator at or after start. Both halves of CRLF remain outside the line.
 */
 function lineEnd(source, start) {
 	const lf = source.indexOf("\n", start);
@@ -532,6 +524,249 @@ function lineEnd(source, start) {
 	if (cr === -1) return lf;
 	return Math.min(lf, cr);
 }
+//#endregion
+//#region src/parser/internal/notation-warning.ts
+function firstCoveredIndex(manuscript, start) {
+	let low = 0;
+	let high = manuscript.graphemes.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const grapheme = manuscript.graphemes[middle];
+		if (grapheme === void 0) return manuscript.graphemes.length;
+		if (grapheme.range.source.end <= start) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+function lastCoveredIndex(manuscript, end) {
+	let low = 0;
+	let high = manuscript.graphemes.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		const grapheme = manuscript.graphemes[middle];
+		if (grapheme === void 0) return -1;
+		if (grapheme.range.source.start < end) low = middle + 1;
+		else high = middle;
+	}
+	return low - 1;
+}
+function spanRange(manuscript, span) {
+	const first = manuscript.graphemes[firstCoveredIndex(manuscript, span.start)];
+	const last = manuscript.graphemes[lastCoveredIndex(manuscript, span.end)];
+	if (first === void 0 || last === void 0 || first.range.source.start >= span.end || last.range.source.end <= span.start) 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 unrecognizedNotationWarnings(source, parserId, manuscript, spans) {
+	return spans.map((span, order) => ManuscriptDiagnostic.of({
+		source,
+		origin: {
+			kind: "parser",
+			id: parserId
+		},
+		severity: "warning",
+		code: `unrecognized-notation-${order}`,
+		message: "認識できない記法を原文として扱いました",
+		range: spanRange(manuscript, span)
+	}));
+}
+//#endregion
+//#region src/parser/kakuyomu-parser.ts
+const PARSER_ID$1 = NamespacedId.of("kg/kakuyomu");
+const MAX_BASE_GRAPHEMES = 20;
+const MAX_READING_GRAPHEMES = 50;
+const HAN = /^\p{Script=Han}$/u;
+function graphemeLength(text) {
+	return [...graphemeSegmenter.segment(text)].length;
+}
+function validRuby(parent, reading) {
+	return parent.length > 0 && reading.length > 0 && !parent.includes("《") && !parent.includes("》") && !reading.includes("《") && !reading.includes("》") && graphemeLength(parent) <= MAX_BASE_GRAPHEMES && graphemeLength(reading) <= MAX_READING_GRAPHEMES;
+}
+function parseRuby(source, parentStart, parentEnd, opening) {
+	const endOfLine = lineEnd(source, opening);
+	const closing = source.indexOf("》", opening + 1);
+	if (closing === -1 || closing >= endOfLine) return void 0;
+	const parent = source.slice(parentStart, parentEnd);
+	const reading = source.slice(opening + 1, closing);
+	if (!validRuby(parent, reading)) return void 0;
+	return {
+		parentStart,
+		parentEnd,
+		reading,
+		end: closing + 1
+	};
+}
+function parseExplicitRuby(source, start) {
+	const endOfLine = lineEnd(source, start + 1);
+	const opening = source.indexOf("《", start + 1);
+	if (opening === -1 || opening >= endOfLine) return void 0;
+	return parseRuby(source, start + 1, opening, opening);
+}
+function parseEmphasis(source, start) {
+	const endOfLine = lineEnd(source, start + 2);
+	const closing = source.indexOf("》》", start + 2);
+	if (closing === -1 || closing >= endOfLine) return void 0;
+	const content = source.slice(start + 2, closing);
+	if (content.length === 0 || content.includes("《") || content.includes("》")) return void 0;
+	return {
+		contentStart: start + 2,
+		contentEnd: closing,
+		end: closing + 2
+	};
+}
+function codePointLength(source, index) {
+	const codePoint = source.codePointAt(index);
+	return codePoint === void 0 || codePoint <= 65535 ? 1 : 2;
+}
+function isHanAt(source, index) {
+	return HAN.test(source.slice(index, index + codePointLength(source, index)));
+}
+function invalidNotationEnd(source, start) {
+	return lineEnd(source, start + 1);
+}
+/**
+* Understands Kakuyomu's ruby and emphasis-mark notation. Invalid notation stays literal so source
+* ranges remain inspectable, while clear notation candidates receive a parser warning.
+*/
+const kakuyomuParser = {
+	id: PARSER_ID$1,
+	parse: (source) => {
+		const draft = createManuscriptDraft(source);
+		const unrecognized = [];
+		let index = 0;
+		let literalStart = 0;
+		let hanRunStart = -1;
+		const appendBefore = (end) => {
+			if (literalStart < end) draft.append(source.slice(literalStart, end), literalStart);
+		};
+		const appendNotationWarning = (start, end) => {
+			unrecognized.push({
+				start,
+				end
+			});
+		};
+		while (index < source.length) {
+			const character = source[index];
+			if (character === "｜" || character === "|") {
+				if (source[index + 1] === "《") {
+					appendBefore(index);
+					draft.append("《", index + 1);
+					index += 2;
+					literalStart = index;
+					hanRunStart = -1;
+					continue;
+				}
+				const ruby = parseExplicitRuby(source, index);
+				if (ruby !== void 0) {
+					appendBefore(index);
+					const range = draft.append(source.slice(ruby.parentStart, ruby.parentEnd), ruby.parentStart);
+					draft.annotate({
+						kind: "ruby",
+						reading: ruby.reading,
+						range: {
+							...range,
+							source: {
+								start: index,
+								end: ruby.end
+							}
+						}
+					});
+					index = ruby.end;
+					literalStart = index;
+					hanRunStart = -1;
+					continue;
+				}
+				const opening = source.indexOf("《", index + 1);
+				if (opening !== -1 && opening < lineEnd(source, index + 1)) {
+					const end = invalidNotationEnd(source, index);
+					appendNotationWarning(index, end);
+					index = end;
+					hanRunStart = -1;
+					continue;
+				}
+			}
+			if (character === "《") {
+				const emphasis = source.startsWith("《《", index) ? parseEmphasis(source, index) : void 0;
+				if (emphasis !== void 0) {
+					appendBefore(index);
+					const range = draft.append(source.slice(emphasis.contentStart, emphasis.contentEnd), emphasis.contentStart);
+					draft.annotate({
+						kind: "emphasis",
+						mark: "・",
+						range: {
+							...range,
+							source: {
+								start: index,
+								end: emphasis.end
+							}
+						}
+					});
+					index = emphasis.end;
+					literalStart = index;
+					hanRunStart = -1;
+					continue;
+				}
+				const ruby = hanRunStart === -1 ? void 0 : parseRuby(source, hanRunStart, index, index);
+				if (ruby !== void 0) {
+					appendBefore(hanRunStart);
+					const range = draft.append(source.slice(ruby.parentStart, ruby.parentEnd), ruby.parentStart);
+					draft.annotate({
+						kind: "ruby",
+						reading: ruby.reading,
+						range: {
+							...range,
+							source: {
+								start: ruby.parentStart,
+								end: ruby.end
+							}
+						}
+					});
+					index = ruby.end;
+					literalStart = index;
+					hanRunStart = -1;
+					continue;
+				}
+				if (source.startsWith("《《", index) || hanRunStart !== -1) appendNotationWarning(hanRunStart === -1 ? index : hanRunStart, invalidNotationEnd(source, index));
+				hanRunStart = -1;
+			} else if (isHanAt(source, index)) {
+				if (hanRunStart === -1) hanRunStart = index;
+			} else hanRunStart = -1;
+			index += codePointLength(source, index);
+		}
+		appendBefore(source.length);
+		const manuscript = draft.build();
+		return ManuscriptResult.succeed(manuscript, unrecognizedNotationWarnings(source, PARSER_ID$1, manuscript, unrecognized));
+	}
+};
+//#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
+	};
+}
 function closingIndex(source, start, closing) {
 	const end = source.indexOf(closing, start);
 	return end !== -1 && end < lineEnd(source, start) ? end : void 0;
@@ -607,49 +842,6 @@ function literalEnd(source, start) {
 //#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.
 */
@@ -692,7 +884,7 @@ const pixivParser = {
 			index = end;
 		}
 		const manuscript = draft.build();
-		return ManuscriptResult.succeed(manuscript, unrecognized.map((span, order) => unrecognizedNotationWarning(source, manuscript, span, order)));
+		return ManuscriptResult.succeed(manuscript, unrecognizedNotationWarnings(source, PARSER_ID, manuscript, unrecognized));
 	}
 };
 //#endregion
@@ -1106,7 +1298,11 @@ function interpolate(template, data) {
 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()))
+	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
@@ -1197,7 +1393,7 @@ function toDiagnostics({ id, messages }, reports, source) {
 				kind: "rule",
 				id
 			},
-			severity: "error",
+			severity: report.severity ?? "error",
 			code: report.messageId,
 			message: interpolate(template, report.data),
 			range: report.range
@@ -1317,8 +1513,9 @@ function defineParsedRule(id, message, check) {
 			messages: { [DEFAULT_MESSAGE_ID]: message }
 		},
 		check: (manuscript, context) => {
-			check(manuscript, (range) => {
+			check(manuscript, (range, options) => {
 				context.report({
+					...options,
 					range,
 					messageId: DEFAULT_MESSAGE_ID
 				});
@@ -1346,6 +1543,148 @@ function defineMatchRule(options) {
 	});
 }
 //#endregion
+//#region src/proofreading/rules/consistent-kanji-opening.ts
+const RULE_ID$4 = "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$2(pairs) {
+	return defineParsedRule(RULE_ID$4, 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$2(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$4,
+		option: "pairs",
+		issues: ValidationIssue.from(pairs.issues)
+	});
+	return ManuscriptResult.succeed(build$2(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-character.ts
+/**
+* Stand-ins for `―`. Repeated `ー` belongs to `kg/no-consecutive-choonpu` and `−` to
+* `kg/minus-before-number`, so neither is reported twice.
+*/
+const dashCharacterRule = () => defineMatchRule({
+	id: "kg/dash-character",
+	pattern: /[—–─━﹣－]+|-{2,}/gu,
+	message: "ダッシュには「―」を使ってください"
+});
+//#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-dash.ts
 const evenDashRule = () => defineMatchRule({
 	id: "kg/even-dash",
@@ -1362,13 +1701,78 @@ const evenEllipsisRule = () => defineMatchRule({
 	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$1 = "kg/max-arabic-numeral-digits";
+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$1,
+		id: RULE_ID$2,
 		pattern: /([0-9０-９]+)(?:[.．]([0-9０-９]+))?/gu,
 		accept: (match) => (match[1]?.length ?? 0) > maxDigits || (match[2]?.length ?? 0) > maxDigits,
 		message: `${maxDigits}桁を超えるアラビア数字が使われています`
@@ -1380,7 +1784,7 @@ function createMaxArabicNumeralDigitsRule(options = {}) {
 	const maxDigits = v.safeParse(MaxDigitsSchema, options.maxDigits);
 	if (!maxDigits.success) return ManuscriptResult.fail({
 		kind: "InvalidRuleOptions",
-		ruleId: RULE_ID$1,
+		ruleId: RULE_ID$2,
 		option: "maxDigits",
 		issues: ValidationIssue.from(maxDigits.issues)
 	});
@@ -1415,46 +1819,151 @@ const noConsecutivePunctuationRule = () => defineMatchRule({
 	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));
+//#region src/proofreading/rules/internal/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/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/internal/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/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 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({
+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,
-		option: "allowedCharacters",
-		issues: ValidationIssue.from(allowed.issues)
+		ruleId: RULE_ID$1,
+		option: "openingBrackets",
+		issues: ValidationIssue.from(brackets.issues)
 	});
-	return ManuscriptResult.succeed(build(allowed.output));
+	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: /[。、]+(?=[」』〗〉》）)”"’'］\]〕｝}＞>])/gu,
+	pattern: PATTERN,
 	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: "感嘆符または疑問符の直後には空白か閉じ括弧が必要です"
+const RULE_ID = "kg/space-after-question-or-exclamation";
+const MESSAGES = {
+	default: "感嘆符または疑問符の直後には全角スペースか閉じ括弧が必要です",
+	"space-width": "感嘆符または疑問符の直後の空白は全角スペース1字にしてください",
+	"before-closing-bracket": "閉じ括弧の直前に空白を置くことはできません"
+};
+/**
+* Runs, not single marks: `！？` is one mark and takes one gap, so the gap belongs after the run.
+*/
+const MARKS = /[？！]+/gu;
+/**
+* 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 marks of line.text.matchAll(MARKS)) {
+			const marksEnd = marks.index + marks[0].length;
+			const next = line.text[marksEnd];
+			if (next === void 0 || "」』〗〉》）)”\"’'］]〕｝}＞>".includes(next)) continue;
+			const spaces = leadingSpaces(line.text.slice(marksEnd));
+			if (spaces === "") {
+				report(line.start + marks.index, line.start + marksEnd, "default");
+				continue;
+			}
+			const following = line.text[marksEnd + spaces.length];
+			const spacesStart = line.start + marksEnd;
+			const spacesEnd = spacesStart + spaces.length;
+			if (following !== void 0 && "」』〗〉》）)”\"’'］]〕｝}＞>".includes(following)) report(spacesStart, spacesEnd, "before-closing-bracket");
+			else if (spaces !== "　") report(spacesStart, spacesEnd, "space-width");
+		}
+	}
 });
 //#endregion
 //#region src/proofreading/rules/variant-character.ts
@@ -1480,21 +1989,27 @@ const variantCharacterRule = () => defineParsedRule("kg/variant-character", "異
 /**
 * 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 [
-		paragraphLeadingCharacterRule(),
+		paragraphOpeningRule(),
 		punctuationBeforeClosingQuoteRule(),
 		spaceAfterQuestionOrExclamationRule(),
 		evenEllipsisRule(),
 		evenDashRule(),
+		ellipsisCharacterRule(),
+		dashCharacterRule(),
 		noConsecutivePunctuationRule(),
 		noConsecutiveInterpunctRule(),
 		noConsecutiveChoonpuRule(),
 		minusBeforeNumberRule(),
 		maxArabicNumeralDigitsRule(),
+		fullwidthJapanesePunctuationRule(),
 		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 };
+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, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashCharacterRule, ellipsisCharacterRule, evenDashRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveChoonpuRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphOpeningRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushichan044/kg-core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",