@sushichan044/kg-core 0.4.1 → 0.6.0

package/dist/index.mjs

@@ -1298,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
@@ -1389,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
@@ -1509,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
 				});
@@ -1538,12 +1543,194 @@ function defineMatchRule(options) {
 	});
 }
 //#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: "連続するダッシュの数は偶数にしてください"
+//#region src/proofreading/rules/consistent-kanji-opening.ts
+const RULE_ID$5 = "kg/consistent-kanji-opening";
+const MESSAGE = "「{{ closed }}」と「{{ opened }}」が混在しています。文脈上の使い分けか表記ゆれかを確認してください";
+const KanjiOpeningPairSchema = v.pipe(readonlyObject({
+	closed: v.pipe(v.string(), v.nonEmpty()),
+	opened: v.pipe(v.string(), v.nonEmpty())
+}), v.check(({ closed, opened }) => closed !== opened, "a pair must hold two different spellings"));
+const PairsSchema = v.pipe(v.array(KanjiOpeningPairSchema), v.nonEmpty(), v.readonly());
+const DEFAULT_PAIRS = [
+	{
+		closed: "出来る",
+		opened: "できる"
+	},
+	{
+		closed: "出来ない",
+		opened: "できない"
+	},
+	{
+		closed: "下さい",
+		opened: "ください"
+	},
+	{
+		closed: "頂く",
+		opened: "いただく"
+	},
+	{
+		closed: "致す",
+		opened: "いたす"
+	},
+	{
+		closed: "何故",
+		opened: "なぜ"
+	},
+	{
+		closed: "為に",
+		opened: "ために"
+	},
+	{
+		closed: "時に",
+		opened: "ときに"
+	},
+	{
+		closed: "様に",
+		opened: "ように"
+	},
+	{
+		closed: "方が",
+		opened: "ほうが"
+	}
+];
+/**
+* Reports the first kanji occurrence of every pair the manuscript also writes in kana. Whether the
+* two spellings are a deliberate distinction is the author's call, so the finding is a warning.
+*/
+function build$3(pairs) {
+	return defineParsedRule(RULE_ID$5, MESSAGE, (manuscript, report) => {
+		for (const { closed, opened } of pairs) {
+			if (!manuscript.displayText.includes(opened)) continue;
+			const index = manuscript.displayText.indexOf(closed);
+			if (index === -1) continue;
+			report(displayRange(manuscript, index, index + closed.length), {
+				data: {
+					closed,
+					opened
+				},
+				severity: "warning"
+			});
+		}
+	});
+}
+const consistentKanjiOpeningRule = () => build$3(DEFAULT_PAIRS);
+function createConsistentKanjiOpeningRule(options = {}) {
+	if (options.pairs === void 0) return ManuscriptResult.succeed(consistentKanjiOpeningRule());
+	const pairs = v.safeParse(PairsSchema, options.pairs);
+	if (!pairs.success) return ManuscriptResult.fail({
+		kind: "InvalidRuleOptions",
+		ruleId: RULE_ID$5,
+		option: "pairs",
+		issues: ValidationIssue.from(pairs.issues)
+	});
+	return ManuscriptResult.succeed(build$3(pairs.output));
+}
+//#endregion
+//#region src/proofreading/rules/internal/mixed-width.ts
+/**
+* Builds a rule that fires when a manuscript uses both widths of one character class. Which width
+* is right is the author's decision, so the finding is a warning, and one finding at the first
+* halfwidth occurrence says everything a list of every mixed character would.
+*/
+function defineMixedWidthRule({ id, message, halfwidth, fullwidth }) {
+	return defineParsedRule(id, message, (manuscript, report) => {
+		const found = halfwidth.exec(manuscript.displayText);
+		const counterpart = fullwidth.exec(manuscript.displayText);
+		if (found === null || counterpart === null) return;
+		report(displayRange(manuscript, found.index, found.index + found[0].length), {
+			data: {
+				halfwidth: found[0],
+				fullwidth: counterpart[0]
+			},
+			severity: "warning"
+		});
+	});
+}
+//#endregion
+//#region src/proofreading/rules/consistent-latin-width.ts
+const consistentLatinWidthRule = () => defineMixedWidthRule({
+	id: "kg/consistent-latin-width",
+	message: "半角英字「{{ halfwidth }}」と全角英字「{{ fullwidth }}」が混在しています。作品内の方針を確認してください",
+	halfwidth: /[A-Za-z]/u,
+	fullwidth: /[Ａ-Ｚａ-ｚ]/u
+});
+//#endregion
+//#region src/proofreading/rules/consistent-numeral-width.ts
+const consistentNumeralWidthRule = () => defineMixedWidthRule({
+	id: "kg/consistent-numeral-width",
+	message: "半角数字「{{ halfwidth }}」と全角数字「{{ fullwidth }}」が混在しています。作品内の方針を確認してください",
+	halfwidth: /[0-9]/u,
+	fullwidth: /[０-９]/u
+});
+//#endregion
+//#region src/proofreading/rules/dash.ts
+const RULE_ID$4 = "kg/dash";
+const DEFAULT_PREFERRED = "―";
+const DashCharacterSchema = v.picklist([
+	"―",
+	"—",
+	"─"
+]);
+const DASH_LIKE_RUN = /[—–―─━﹣－-]+/gu;
+const EVEN_COUNT_MESSAGE = "連続するダッシュの数は偶数にしてください";
+function messageIdFor(run, preferred) {
+	if (run === "-") return void 0;
+	if (run !== preferred.repeat(run.length)) return "character";
+	return run.length % 2 === 1 ? "even-count" : void 0;
+}
+function build$2(preferred) {
+	const messages = {
+		character: `ダッシュには「${preferred}」を使ってください`,
+		"even-count": EVEN_COUNT_MESSAGE
+	};
+	return {
+		kind: "parsed",
+		meta: {
+			id: RULE_ID$4,
+			messages
+		},
+		check: (manuscript, context) => {
+			for (const line of splitDisplayLines(manuscript.displayText)) {
+				DASH_LIKE_RUN.lastIndex = 0;
+				let match = DASH_LIKE_RUN.exec(line.text);
+				while (match !== null) {
+					const run = match[0];
+					const messageId = messageIdFor(run, preferred);
+					if (messageId !== void 0) {
+						const start = line.start + match.index;
+						context.report({
+							range: displayRange(manuscript, start, start + run.length),
+							messageId
+						});
+					}
+					match = DASH_LIKE_RUN.exec(line.text);
+				}
+			}
+		}
+	};
+}
+const dashRule = () => build$2(DEFAULT_PREFERRED);
+function createDashRule(options = {}) {
+	if (options.preferred === void 0) return ManuscriptResult.succeed(dashRule());
+	const preferred = v.safeParse(DashCharacterSchema, options.preferred);
+	if (!preferred.success) return ManuscriptResult.fail({
+		kind: "InvalidRuleOptions",
+		ruleId: RULE_ID$4,
+		option: "preferred",
+		issues: ValidationIssue.from(preferred.issues)
+	});
+	return ManuscriptResult.succeed(build$2(preferred.output));
+}
+//#endregion
+//#region src/proofreading/rules/ellipsis-character.ts
+/**
+* Stand-ins for `…`. Runs of `。` and `・` are left to the rules that already count them, so one
+* substitute is never reported twice.
+*/
+const ellipsisCharacterRule = () => defineMatchRule({
+	id: "kg/ellipsis-character",
+	pattern: /\.{3,}|⋯+/gu,
+	message: "三点リーダーには「…」を使ってください"
 });
 //#endregion
 //#region src/proofreading/rules/even-ellipsis.ts
@@ -1554,13 +1741,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}桁を超えるアラビア数字が使われています`
@@ -1572,7 +1824,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)
 	});
@@ -1586,13 +1838,6 @@ const minusBeforeNumberRule = () => defineMatchRule({
 	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",
@@ -1607,46 +1852,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
@@ -1672,21 +2022,25 @@ 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(),
+		dashRule(),
+		ellipsisCharacterRule(),
 		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, kakuyomuParser, 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, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, kakuyomuParser, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, 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.1",
+  "version": "0.6.0",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",