@sushichan044/kg-core 0.3.0 → 0.4.1

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
@@ -1497,4 +1689,4 @@ function createDefaultProofreadingRules() {
 	];
 }
 //#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, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphLeadingCharacterRule, evenDashRule, evenEllipsisRule, kakuyomuParser, manuscriptGridComposer, maxArabicNumeralDigitsRule, minusBeforeNumberRule, mmToPt, noConsecutiveChoonpuRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphLeadingCharacterRule, parseManuscript, pixivParser, plainTextParser, proofreadManuscript, ptToMm, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };

package/package.json

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