@sushichan044/kg-core 0.9.2 → 0.9.4

package/README.md

@@ -81,8 +81,11 @@ The composer classifies the core prose classes from JLReq, resolves pair spacing
 and selects line breaks over the whole source paragraph. The space between two
 classes follows appendix 表1 of JLReq: a half em before an opening bracket and after
 a closing bracket, comma, or full stop, a quarter em on either side of a middle dot,
-a quarter em between Japanese and a numeral, unit symbol, or Western character, and
-solid where two of those punctuation marks meet.
+a quarter em between Japanese and a numeral, unit symbol, or a Western character rotated
+90 degrees or mixed into horizontal text, and solid where two of those punctuation marks
+meet. JLReq 3.2.4 sets that quarter em's scope: a Western character set upright — one letter,
+an all-caps or `Xxx` abbreviation, a lone digit, or a full-width letter — classes with kanji
+instead and sits solid against the kana or kanji beside it, the same as a tate-chu-yoko run.
 
 A western word space is not a character with a box but an アキ of its own: a third em
 by rule rather than by measurement, nothing at all at a line head or a line end, and
@@ -100,7 +103,8 @@ added equally to the admitted pairs in 表6 that are solid at rest, including pa
 the third stage. Intrinsic spaces keep their finite limits: a word space and a mixed
 Japanese-to-Western, numeral, or unit-symbol gap stop at a half em, while punctuation and
 explicit full-em spaces retain their own width. This keeps the unbounded stage from producing
-conspicuous holes around short upright Western words or already-spaced marks.
+double space or a hole disproportionate to a horizontal Western run's own length, since an
+upright Western run classes with kanji and has no gap of its own to begin with.
 Line-head and line-end space, inseparable pairs, and source-authored full-em gaps after
 question or exclamation marks stay fixed. A line with no admitted gap is forced. The choice is made for the
 paragraph rather than line by line,
@@ -145,6 +149,11 @@ words remain unbroken and render sideways, and two ASCII digits form one
 tate-chu-yoko unit. The resulting `VerticalTextPresentation` is carried by every
 glyph item, so renderers do not need to infer orientation independently.
 
+An upright Western character sets solid against the kana or kanji beside it rather than
+taking the quarter em 3.2.6 puts around a sideways run, following JLReq 3.2.4: it classes
+with kanji, the same way 3.2.5 classes a tate-chu-yoko run. `QR` and `URL` set upright by
+this rule read flush against their surrounding Japanese text, the way a kanji compound does.
+
 The default logical measurer uses East Asian Width in a Japanese context. Upright
 ASCII advances by one em; proportional ASCII and the members of a tate-chu-yoko unit
 advance by half an em. Supply a synchronous measurer when the caller has more accurate

package/dist/{composed-manuscript-QgIdae8p.d.mts → composed-manuscript-C0f3mxKs.d.mts}

@@ -914,7 +914,7 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
     }>;
     mark: string;
   }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
-    kind: "ruby";
+    kind: "italic";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -929,18 +929,8 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
-    reading: Readonly<{
-      kind: "group";
-      text: string;
-    }> | Readonly<{
-      kind: "mono";
-      readonly segments: readonly string[];
-    }> | Readonly<{
-      kind: "jukugo";
-      readonly segments: readonly string[];
-    }>;
   }> | Readonly<{
-    kind: "bold";
+    kind: "ruby";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -955,8 +945,18 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
+    reading: Readonly<{
+      kind: "group";
+      text: string;
+    }> | Readonly<{
+      kind: "mono";
+      readonly segments: readonly string[];
+    }> | Readonly<{
+      kind: "jukugo";
+      readonly segments: readonly string[];
+    }>;
   }> | Readonly<{
-    kind: "italic";
+    kind: "bold";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1010,7 +1010,7 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
     }>;
   }>[];
   readonly annotations: readonly (Readonly<{
-    kind: "ruby";
+    kind: "italic";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1025,18 +1025,8 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
-    reading: Readonly<{
-      kind: "group";
-      text: string;
-    }> | Readonly<{
-      kind: "mono";
-      readonly segments: readonly string[];
-    }> | Readonly<{
-      kind: "jukugo";
-      readonly segments: readonly string[];
-    }>;
   }> | Readonly<{
-    kind: "bold";
+    kind: "ruby";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1051,8 +1041,18 @@ declare const ParsedManuscriptSchema: v.SchemaWithPipe<readonly [v.StrictObjectS
         end: number;
       }> & v.Brand<"GraphemeRange">;
     }>;
+    reading: Readonly<{
+      kind: "group";
+      text: string;
+    }> | Readonly<{
+      kind: "mono";
+      readonly segments: readonly string[];
+    }> | Readonly<{
+      kind: "jukugo";
+      readonly segments: readonly string[];
+    }>;
   }> | Readonly<{
-    kind: "italic";
+    kind: "bold";
     readonly range: Readonly<{
       source: Readonly<{
         start: number;
@@ -1503,7 +1503,7 @@ declare const ParsedManuscript: {
       }>;
       mark: string;
     }>]>], undefined>, undefined>, v.ReadonlyAction<(Readonly<{
-      kind: "ruby";
+      kind: "italic";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1518,18 +1518,8 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
-      reading: Readonly<{
-        kind: "group";
-        text: string;
-      }> | Readonly<{
-        kind: "mono";
-        readonly segments: readonly string[];
-      }> | Readonly<{
-        kind: "jukugo";
-        readonly segments: readonly string[];
-      }>;
     }> | Readonly<{
-      kind: "bold";
+      kind: "ruby";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1544,8 +1534,18 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
+      reading: Readonly<{
+        kind: "group";
+        text: string;
+      }> | Readonly<{
+        kind: "mono";
+        readonly segments: readonly string[];
+      }> | Readonly<{
+        kind: "jukugo";
+        readonly segments: readonly string[];
+      }>;
     }> | Readonly<{
-      kind: "italic";
+      kind: "bold";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1599,7 +1599,7 @@ declare const ParsedManuscript: {
       }>;
     }>[];
     readonly annotations: readonly (Readonly<{
-      kind: "ruby";
+      kind: "italic";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1614,18 +1614,8 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
-      reading: Readonly<{
-        kind: "group";
-        text: string;
-      }> | Readonly<{
-        kind: "mono";
-        readonly segments: readonly string[];
-      }> | Readonly<{
-        kind: "jukugo";
-        readonly segments: readonly string[];
-      }>;
     }> | Readonly<{
-      kind: "bold";
+      kind: "ruby";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;
@@ -1640,8 +1630,18 @@ declare const ParsedManuscript: {
           end: number;
         }> & v.Brand<"GraphemeRange">;
       }>;
+      reading: Readonly<{
+        kind: "group";
+        text: string;
+      }> | Readonly<{
+        kind: "mono";
+        readonly segments: readonly string[];
+      }> | Readonly<{
+        kind: "jukugo";
+        readonly segments: readonly string[];
+      }>;
     }> | Readonly<{
-      kind: "italic";
+      kind: "bold";
       readonly range: Readonly<{
         source: Readonly<{
           start: number;

package/dist/index.d.mts

@@ -1,11 +1,11 @@
-import { a as ManuscriptResult, c as DiagnosticSeverity, d as ManuscriptRangeInput, i as ParsedManuscript, l as DiagnosticOrigin, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, s as ManuscriptDiagnosticInput, t as ComposedManuscript, u as ManuscriptRange } from "./composed-manuscript-QgIdae8p.mjs";
-import { d as NovelCompositionSettings, f as ManuscriptComposer, i as NovelLayout, l as VerticalTextPresentation, p as ManuscriptParser, r as novelComposer, t as NovelComposedManuscript, u as FontPresetId } from "./novel-composer-BCt9g172.mjs";
+import { a as ManuscriptResult, c as DiagnosticSeverity, d as ManuscriptRangeInput, i as ParsedManuscript, l as DiagnosticOrigin, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, s as ManuscriptDiagnosticInput, t as ComposedManuscript, u as ManuscriptRange } from "./composed-manuscript-C0f3mxKs.mjs";
+import { d as NovelCompositionSettings, f as ManuscriptComposer, i as NovelLayout, l as VerticalTextPresentation, p as ManuscriptParser, r as novelComposer, t as NovelComposedManuscript, u as FontPresetId } from "./novel-composer-DhycV9B3.mjs";
 import * as v from "valibot";
 //#region src/parser/parse-error.d.ts
 /**
  * Everything that can go wrong while turning source text into a {@link ParsedManuscript}.
  */
-type ParseError = Readonly<{
+export type ParseError = Readonly<{
   kind: "InvalidParserId";
   parserId: string;
 }> | Readonly<{
@@ -21,7 +21,7 @@ type ParseError = Readonly<{
   parserId: NamespacedId;
   cause: unknown;
 }>;
-declare const ParseError: {
+export declare const ParseError: {
   /**
    * Human-readable rendering. Branch on `kind` instead when the caller needs to react.
    */
@@ -33,27 +33,27 @@ type ParseManuscriptOptions = Readonly<{
   parser?: ManuscriptParser;
 }>;
 type ParseOutcome = ManuscriptResult<ParsedManuscript, ParseError>;
-declare function parseManuscript(source: string, options?: ParseManuscriptOptions): ParseOutcome;
+export declare function parseManuscript(source: string, options?: ParseManuscriptOptions): ParseOutcome;
 //#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;
+export 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
  * does not parse is kept as literal text and reported as a warning rather than dropped.
  */
-declare const pixivParser: ManuscriptParser;
+export declare const pixivParser: ManuscriptParser;
 //#endregion
 //#region src/parser/plain-text-parser.d.ts
 /**
  * Treats the source verbatim: no notation, no annotations, display text equals source.
  */
-declare const plainTextParser: ManuscriptParser;
+export declare const plainTextParser: ManuscriptParser;
 //#endregion
 //#region src/parser/parsed-grapheme.d.ts
 declare const ParsedGraphemeSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
@@ -1596,7 +1596,7 @@ declare const RubyAnnotation: {
 /**
  * Everything that can go wrong while placing a parsed manuscript onto pages.
  */
-type ComposeError = Readonly<{
+export type ComposeError = Readonly<{
   kind: "InvalidComposerId";
   composerId: string;
 }> | Readonly<{
@@ -1619,7 +1619,7 @@ type ComposeError = Readonly<{
   composerId: NamespacedId;
   cause: unknown;
 }>;
-declare const ComposeError: {
+export declare const ComposeError: {
   /**
    * Human-readable rendering. Branch on `kind` instead when the caller needs to react.
    */
@@ -1631,7 +1631,7 @@ type ComposeManuscriptOptions<TSettings, TLayout> = Readonly<{
   composer: ManuscriptComposer<TSettings, TLayout>;
   settings: TSettings;
 }>;
-declare function composeManuscript<TSettings, TLayout>(parsed: ParsedManuscript, options: ComposeManuscriptOptions<TSettings, TLayout>): ManuscriptResult<ComposedManuscript<TSettings, TLayout>, ComposeError>;
+export declare function composeManuscript<TSettings, TLayout>(parsed: ParsedManuscript, options: ComposeManuscriptOptions<TSettings, TLayout>): ManuscriptResult<ComposedManuscript<TSettings, TLayout>, ComposeError>;
 //#endregion
 //#region src/composer/novel-flow-settings.d.ts
 declare const NovelFlowSettingsSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
@@ -1651,8 +1651,8 @@ declare const NovelFlowSettingsSchema: v.SchemaWithPipe<readonly [v.StrictObject
  * These are counts of em cells, not physical lengths. `ManuscriptGeometry` turns them into
  * millimetres once a paper size and a font size are known.
  */
-type NovelFlowSettings = v.InferOutput<typeof NovelFlowSettingsSchema>;
-declare const NovelFlowSettings: {
+export type NovelFlowSettings = v.InferOutput<typeof NovelFlowSettingsSchema>;
+export declare const NovelFlowSettings: {
   readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
     readonly lineLengthEm: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>;
     readonly linesPerStage: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>;
@@ -1748,8 +1748,8 @@ declare const ManuscriptOffsetsSchema: v.SchemaWithPipe<readonly [v.StrictObject
  * novel reserves the opening pages and keeps the top and bottom of each block of text clear, in
  * whole lines rather than in millimetres, so the grid stays intact.
  */
-type ManuscriptOffsets = v.InferOutput<typeof ManuscriptOffsetsSchema>;
-declare const ManuscriptOffsets: {
+export type ManuscriptOffsets = v.InferOutput<typeof ManuscriptOffsetsSchema>;
+export declare const ManuscriptOffsets: {
   readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
     readonly document: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
       readonly leading: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
@@ -1823,8 +1823,8 @@ declare const ManuscriptAppearanceSettingsSchema: v.SchemaWithPipe<readonly [v.S
 /**
  * Everything that changes the physical dimensions of a page, but not how text fills the grid.
  */
-type ManuscriptAppearanceSettings = v.InferOutput<typeof ManuscriptAppearanceSettingsSchema>;
-declare const ManuscriptAppearanceSettings: {
+export type ManuscriptAppearanceSettings = v.InferOutput<typeof ManuscriptAppearanceSettingsSchema>;
+export declare const ManuscriptAppearanceSettings: {
   readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
     readonly paperSize: v.PicklistSchema<["a4", "a5", "a6", "jis-b5", "jis-b6", "shinsho"], undefined>;
     readonly fontSizePt: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 6, undefined>, v.MaxValueAction<number, 24, undefined>, v.MultipleOfAction<number, 0.5, undefined>]>;
@@ -1847,8 +1847,8 @@ declare const PaperSizeIdSchema: v.PicklistSchema<["a4", "a5", "a6", "jis-b5", "
  * ISO A sizes, the JIS B series (which is not the ISO B series), and the two trim sizes Japanese
  * publishing names rather than measures: A6 is the 文庫本 and `shinsho` the 新書判.
  */
-type PaperSizeId = v.InferOutput<typeof PaperSizeIdSchema>;
-declare const PaperSizeId: {
+export type PaperSizeId = v.InferOutput<typeof PaperSizeIdSchema>;
+export declare const PaperSizeId: {
   readonly schema: v.PicklistSchema<["a4", "a5", "a6", "jis-b5", "jis-b6", "shinsho"], undefined>;
   readonly is: (value: unknown) => value is PaperSizeId;
 };
@@ -1885,8 +1885,8 @@ declare const ManuscriptGeometrySchema: v.SchemaWithPipe<readonly [v.StrictObjec
  * `fitsPaper` is false when the requested grid is larger than the paper. The geometry is still
  * returned in full so a caller can show what overflowed instead of being handed nothing.
  */
-type ManuscriptGeometry = v.InferOutput<typeof ManuscriptGeometrySchema>;
-declare const ManuscriptGeometry: {
+export type ManuscriptGeometry = v.InferOutput<typeof ManuscriptGeometrySchema>;
+export declare const ManuscriptGeometry: {
   readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
     readonly paperWidthMm: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     readonly paperHeightMm: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -1918,12 +1918,12 @@ declare const ManuscriptGeometry: {
 };
 //#endregion
 //#region src/appearance/font-preset.d.ts
-type FontPreset = Readonly<{
+export type FontPreset = Readonly<{
   id: FontPresetId;
   label: string;
   family: string;
 }>;
-declare const FontPreset: {
+export declare const FontPreset: {
   readonly of: (id: FontPresetId) => FontPreset;
   readonly all: readonly Readonly<{
     id: FontPresetId;
@@ -1937,8 +1937,8 @@ declare const FontSizePtSchema: v.SchemaWithPipe<readonly [v.NumberSchema<undefi
 /**
  * A manuscript cell pitch in points, constrained to the steps the settings UI can express.
  */
-type FontSizePt = v.InferOutput<typeof FontSizePtSchema>;
-declare const FontSizePt: {
+export type FontSizePt = v.InferOutput<typeof FontSizePtSchema>;
+export declare const FontSizePt: {
   readonly schema: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.MinValueAction<number, 6, undefined>, v.MaxValueAction<number, 24, undefined>, v.MultipleOfAction<number, 0.5, undefined>]>;
   readonly range: {
     readonly min: 6;
@@ -1949,13 +1949,13 @@ declare const FontSizePt: {
 };
 //#endregion
 //#region src/appearance/paper-size.d.ts
-type PaperSize = Readonly<{
+export type PaperSize = Readonly<{
   id: PaperSizeId;
   label: string;
   widthMm: number;
   heightMm: number;
 }>;
-declare const PaperSize: {
+export declare const PaperSize: {
   readonly of: (id: PaperSizeId) => PaperSize;
   readonly all: readonly Readonly<{
     id: PaperSizeId;
@@ -20985,4 +20985,4 @@ declare const TextRange: {
   }>, "range end must not precede its start">]>;
 };
 //#endregion
-export { type BoldAnnotation, ComposeError, type ComposeManuscriptOptions, type ComposedAnnotationFragment, type ComposedGlue, type ComposedGlyph, type ComposedInlineItem, type ComposedKern, type ComposedManuscript, type CompositionStatistics, type DiagnosticOrigin, type DiagnosticSeverity, type DisplayRange, type EmphasisAnnotation, FontPreset, FontPresetId, FontSizePt, type GraphemeRange, type InlineSpan, type ItalicAnnotation, type LineBreakResult, type LineOffset, type ManuscriptAnnotation, ManuscriptAppearanceSettings, ManuscriptDiagnostic, type ManuscriptDiagnosticInput, ManuscriptGeometry, ManuscriptOffsets, ManuscriptRange, type ManuscriptRangeInput, ManuscriptResult, type NovelComposedManuscript, NovelCompositionSettings, NovelFlowSettings, type NovelLayout, type NovelLine, type NovelPage, type NovelStage, PaperSize, PaperSizeId, ParseError, type ParseManuscriptOptions, type ParsedGrapheme, type ParsedManuscript, type RubyAnnotation, type RubyKind, type RubyReading, type SourcePosition, type SourceRange, type SuppressedInlineItem, type TextRange, type VerticalTextPresentation, composeManuscript, kakuyomuParser, novelComposer, parseManuscript, pixivParser, plainTextParser };
+export { type BoldAnnotation, type ComposeManuscriptOptions, type ComposedAnnotationFragment, type ComposedGlue, type ComposedGlyph, type ComposedInlineItem, type ComposedKern, type ComposedManuscript, type CompositionStatistics, type DiagnosticOrigin, type DiagnosticSeverity, type DisplayRange, type EmphasisAnnotation, FontPresetId, type GraphemeRange, type InlineSpan, type ItalicAnnotation, type LineBreakResult, type LineOffset, type ManuscriptAnnotation, ManuscriptDiagnostic, type ManuscriptDiagnosticInput, ManuscriptRange, type ManuscriptRangeInput, ManuscriptResult, type NovelComposedManuscript, NovelCompositionSettings, type NovelLayout, type NovelLine, type NovelPage, type NovelStage, type ParseManuscriptOptions, type ParsedGrapheme, type ParsedManuscript, type RubyAnnotation, type RubyKind, type RubyReading, type SourcePosition, type SourceRange, type SuppressedInlineItem, type TextRange, type VerticalTextPresentation, novelComposer };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { c as ManuscriptResult, d as NamespacedId, f as ManuscriptRange, h as readonlyObject, l as ManuscriptDiagnostic, o as graphemeSegmenter, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-CNBT4TDN.mjs";
+import { c as ManuscriptOffsets, d as FontSizePt, f as FontPresetId, i as PaperSize, l as ManuscriptAppearanceSettings, n as novelComposer, o as NovelCompositionSettings, p as ParsedManuscript, r as ManuscriptGeometry, s as NovelFlowSettings, u as PaperSizeId } from "./novel-composer-DRgsEA2s.mjs";
 import { n as assertNever, t as describeCause } from "./describe-cause-BV8mZ3Um.mjs";
 import * as v from "valibot";
 const Rejection = { schema: readonlyObject({ reason: v.string() }) };

package/dist/lint.d.mts

@@ -1,17 +1,17 @@
-import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, t as ComposedManuscript } from "./composed-manuscript-QgIdae8p.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, o as ManuscriptDiagnostic, r as NamespacedId, t as ComposedManuscript } from "./composed-manuscript-C0f3mxKs.mjs";
 import * as v from "valibot";
 //#region src/proofreading/invalid-rule-options.d.ts
 /**
  * A built-in rule factory was given options it cannot honour. Distinct from {@link ProofreadError}
  * because it happens while configuring rules, long before any manuscript is checked.
  */
-type InvalidRuleOptions = Readonly<{
+export type InvalidRuleOptions = Readonly<{
   kind: "InvalidRuleOptions";
   ruleId: string;
   option: string;
   issues: readonly ValidationIssue[];
 }>;
-declare const InvalidRuleOptions: {
+export declare const InvalidRuleOptions: {
   readonly describe: (error: InvalidRuleOptions) => string;
 };
 //#endregion
@@ -19,7 +19,7 @@ declare const InvalidRuleOptions: {
 /**
  * Everything that can go wrong while running a set of rules over a manuscript.
  */
-type ProofreadError = Readonly<{
+export type ProofreadError = Readonly<{
   kind: "InvalidRuleId";
   ruleId: string;
 }> | Readonly<{
@@ -42,7 +42,7 @@ type ProofreadError = Readonly<{
   ruleId: NamespacedId;
   cause: unknown;
 }>;
-declare const ProofreadError: {
+export declare const ProofreadError: {
   /**
    * Human-readable rendering. Branch on `kind` instead when the caller needs to react.
    */
@@ -253,8 +253,8 @@ declare const ProofreadingRuleMetaSchema: v.SchemaWithPipe<readonly [v.StrictObj
     [x: string]: string;
   }>;
 }>]>;
-type ProofreadingRuleMeta = v.InferOutput<typeof ProofreadingRuleMetaSchema>;
-declare const ProofreadingRuleMeta: {
+export type ProofreadingRuleMeta = v.InferOutput<typeof ProofreadingRuleMetaSchema>;
+export declare const ProofreadingRuleMeta: {
   readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
     readonly id: v.StringSchema<undefined>;
     readonly messages: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, v.ReadonlyAction<{
@@ -300,12 +300,12 @@ type ProofreadOptions<TRule> = Readonly<{
 }>;
 type Diagnostics = readonly ManuscriptDiagnostic[];
 type ProofreadOutcome = ManuscriptResult<Diagnostics, ProofreadError>;
-declare function proofreadManuscript(manuscript: ParsedManuscript, options: ProofreadOptions<ParsedProofreadingRule>): ProofreadOutcome;
+export declare function proofreadManuscript(manuscript: ParsedManuscript, options: ProofreadOptions<ParsedProofreadingRule>): ProofreadOutcome;
 /**
  * Rules are typed against the exact composed manuscript being checked, so a grid-specific rule
  * cannot be handed a manuscript from a different composer.
  */
-declare function proofreadManuscript<TComposed extends ComposedManuscript>(manuscript: TComposed, options: ProofreadOptions<ParsedProofreadingRule | ComposedProofreadingRule<TComposed>>): ProofreadOutcome;
+export 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<{
@@ -328,8 +328,8 @@ type KanjiOpeningPair = v.InferOutput<typeof KanjiOpeningPairSchema>;
 type ConsistentKanjiOpeningOptions = Readonly<{
   pairs?: readonly KanjiOpeningPair[];
 }>;
-declare const consistentKanjiOpeningRule: () => ParsedProofreadingRule;
-declare function createConsistentKanjiOpeningRule(options?: ConsistentKanjiOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+export declare const consistentKanjiOpeningRule: () => ParsedProofreadingRule;
+export declare function createConsistentKanjiOpeningRule(options?: ConsistentKanjiOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
 //#endregion
 //#region src/proofreading/rules/consistent-latin-width.d.ts
 /**
@@ -338,7 +338,7 @@ declare function createConsistentKanjiOpeningRule(options?: ConsistentKanjiOpeni
  * 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.
  */
-declare const consistentLatinWidthRule: () => ParsedProofreadingRule;
+export declare const consistentLatinWidthRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/consistent-numeral-width.d.ts
 /**
@@ -346,7 +346,7 @@ declare const consistentLatinWidthRule: () => ParsedProofreadingRule;
  * 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.
  */
-declare const consistentNumeralWidthRule: () => ParsedProofreadingRule;
+export declare const consistentNumeralWidthRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/dash.d.ts
 declare const DashCharacterSchema: v.PicklistSchema<readonly ["―", "—", "─"], undefined>;
@@ -354,8 +354,8 @@ type DashCharacter = v.InferOutput<typeof DashCharacterSchema>;
 type DashOptions = Readonly<{
   preferred?: DashCharacter;
 }>;
-declare const dashRule: () => ParsedProofreadingRule;
-declare function createDashRule(options?: DashOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+export declare const dashRule: () => ParsedProofreadingRule;
+export declare function createDashRule(options?: DashOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
 //#endregion
 //#region src/proofreading/rules/default-rules.d.ts
 /**
@@ -365,7 +365,7 @@ declare function createDashRule(options?: DashOptions): ManuscriptResult<ParsedP
  * 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[];
+export declare function createDefaultProofreadingRules(): readonly ParsedProofreadingRule[];
 //#endregion
 //#region src/proofreading/rules/ellipsis-character.d.ts
 /**
@@ -373,14 +373,14 @@ declare function createDefaultProofreadingRules(): readonly ParsedProofreadingRu
  * 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.
  */
-declare const ellipsisCharacterRule: () => ParsedProofreadingRule;
+export declare const ellipsisCharacterRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/even-ellipsis.d.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.
  */
-declare const evenEllipsisRule: () => ParsedProofreadingRule;
+export declare const evenEllipsisRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/fullwidth-japanese-punctuation.d.ts
 /**
@@ -392,14 +392,14 @@ declare const evenEllipsisRule: () => ParsedProofreadingRule;
  * The three checks differ in how much the surroundings decide the answer, which is why only the
  * first is decisive on its own.
  */
-declare const fullwidthJapanesePunctuationRule: () => ParsedProofreadingRule;
+export declare const fullwidthJapanesePunctuationRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/max-arabic-numeral-digits.d.ts
 type MaxArabicNumeralDigitsOptions = Readonly<{
   maxDigits?: number;
 }>;
-declare const maxArabicNumeralDigitsRule: () => ParsedProofreadingRule;
-declare function createMaxArabicNumeralDigitsRule(options?: MaxArabicNumeralDigitsOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+export declare const maxArabicNumeralDigitsRule: () => ParsedProofreadingRule;
+export declare function createMaxArabicNumeralDigitsRule(options?: MaxArabicNumeralDigitsOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
 //#endregion
 //#region src/proofreading/rules/minus-before-number.d.ts
 /**
@@ -407,14 +407,14 @@ declare function createMaxArabicNumeralDigitsRule(options?: MaxArabicNumeralDigi
  * prolonged sound mark, which look alike but belong to different character classes and so are
  * spaced and broken differently.
  */
-declare const minusBeforeNumberRule: () => ParsedProofreadingRule;
+export declare const minusBeforeNumberRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/no-consecutive-interpunct.d.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.
  */
-declare const noConsecutiveInterpunctRule: () => ParsedProofreadingRule;
+export declare const noConsecutiveInterpunctRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/no-consecutive-punctuation.d.ts
 /**
@@ -422,14 +422,14 @@ declare const noConsecutiveInterpunctRule: () => ParsedProofreadingRule;
  * so a run of them is not punctuation at all: it is a sentence trailing off, which Japanese prose
  * writes with `…`.
  */
-declare const noConsecutivePunctuationRule: () => ParsedProofreadingRule;
+export declare const noConsecutivePunctuationRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/paragraph-opening.d.ts
 type ParagraphOpeningOptions = Readonly<{
   openingBrackets?: string;
 }>;
-declare const paragraphOpeningRule: () => ParsedProofreadingRule;
-declare function createParagraphOpeningRule(options?: ParagraphOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+export declare const paragraphOpeningRule: () => ParsedProofreadingRule;
+export declare function createParagraphOpeningRule(options?: ParagraphOpeningOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
 //#endregion
 //#region src/proofreading/rules/punctuation-before-closing-quote.d.ts
 /**
@@ -437,7 +437,7 @@ declare function createParagraphOpeningRule(options?: ParagraphOpeningOptions):
  * 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.
  */
-declare const punctuationBeforeClosingQuoteRule: () => ParsedProofreadingRule;
+export declare const punctuationBeforeClosingQuoteRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/space-after-question-or-exclamation.d.ts
 /**
@@ -446,7 +446,7 @@ declare const punctuationBeforeClosingQuoteRule: () => ParsedProofreadingRule;
  * 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.
  */
-declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
+export declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
 //#endregion
 //#region src/proofreading/rules/variant-character.d.ts
 /**
@@ -456,6 +456,6 @@ declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
  *
  * Scans the source rather than the display text: notation removal must not hide a variant.
  */
-declare const variantCharacterRule: () => ParsedProofreadingRule;
+export declare const variantCharacterRule: () => ParsedProofreadingRule;
 //#endregion
-export { type ComposedProofreadingRule, type ConsistentKanjiOpeningOptions, type DashOptions, InvalidRuleOptions, type KanjiOpeningPair, type MaxArabicNumeralDigitsOptions, type ParagraphOpeningOptions, type ParsedProofreadingRule, ProofreadError, type ProofreadOptions, type ProofreadingReport, type ProofreadingRule, type ProofreadingRuleContext, type ProofreadingRuleMessages, ProofreadingRuleMeta, consistentKanjiOpeningRule, consistentLatinWidthRule, consistentNumeralWidthRule, createConsistentKanjiOpeningRule, createDashRule, createDefaultProofreadingRules, createMaxArabicNumeralDigitsRule, createParagraphOpeningRule, dashRule, ellipsisCharacterRule, evenEllipsisRule, fullwidthJapanesePunctuationRule, maxArabicNumeralDigitsRule, minusBeforeNumberRule, noConsecutiveInterpunctRule, noConsecutivePunctuationRule, paragraphOpeningRule, proofreadManuscript, punctuationBeforeClosingQuoteRule, spaceAfterQuestionOrExclamationRule, variantCharacterRule };
+export type { ComposedProofreadingRule, ConsistentKanjiOpeningOptions, DashOptions, KanjiOpeningPair, MaxArabicNumeralDigitsOptions, ParagraphOpeningOptions, ParsedProofreadingRule, ProofreadOptions, ProofreadingReport, ProofreadingRule, ProofreadingRuleContext, ProofreadingRuleMessages };

package/dist/{novel-composer-CNBT4TDN.mjs → novel-composer-DRgsEA2s.mjs}

@@ -306,11 +306,19 @@ const HIRAGANA = /^\p{Script=Hiragana}$/u;
 const KATAKANA = /^\p{Script=Katakana}$/u;
 const WESTERN = /^[\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}]$/u;
 /**
-* Order matters: a character inside a tate-chu-yoko group is cl-30 whatever it would be on its own,
-* and anything left unmatched is cl-19, the class JLReq reserves for kanji and the like.
+* Order matters: a character inside a tate-chu-yoko group is cl-30 (3.2.5) and an upright Latin
+* letter or Arabic numeral is cl-19 (3.2.4), whatever either would be on its own; anything left
+* unmatched is cl-19 too, the class JLReq reserves for kanji and the like.
+*
+* The quarter em 3.2.6 sets between Japanese and a Western character or numeral applies only to a
+* character rotated 90 degrees in vertical writing mode or mixed into horizontal writing mode —
+* 3.2.6 states that scope explicitly. A character set upright keeps its own rule, 3.2.4, which
+* reads it as a full-width monospace glyph classed with kanji and set solid against its neighbours,
+* the same as a tate-chu-yoko run's 3.2.5.
 */
 function classify({ value, presentation }) {
 	if (presentation === "tate-chu-yoko") return "cl-30";
+	if (presentation === "upright") return "cl-19";
 	if (OPENING.has(value)) return "cl-01";
 	if (CLOSING.has(value)) return "cl-02";
 	if (HYPHENS.has(value)) return "cl-03";
@@ -457,7 +465,9 @@ const FIXED_QUARTER = {
 };
 /**
 * `1/4-1/8` in 表3 with `1/4-1/2` in 表6: the Japanese-to-western quarter em, reducible to an eighth
-* and expandable to a half.
+* and expandable to a half. 3.2.6 sets this only against a Western character rotated 90 degrees or
+* mixed into horizontal text (cl-27) and a numeral or unit symbol (cl-24, cl-25); an upright
+* Western character classifies as cl-19 instead and never reaches this constant.
 */
 const MIXED_TEXT_QUARTER = {
 	kind: "glue",
@@ -568,9 +578,10 @@ const EDGE_WORD_SPACE = {
 	naturalWidthEm: 0
 };
 /**
-* The classes that take a quarter em against a numeral, unit symbol or western character (3.2.6).
-* Dividing punctuation is on the list in that direction only, because the space before a `？` or `！`
-* is solid (3.1.6).
+* The classes that take a quarter em against a numeral, unit symbol or western character rotated 90
+* degrees or mixed into horizontal text (3.2.6) — an upright western character classifies as cl-19
+* and is covered by the general kanji rows and columns instead. Dividing punctuation is on the list
+* in that direction only, because the space before a `？` or `！` is solid (3.1.6).
 */
 const JAPANESE_BEFORE_WESTERN = [
 	"cl-04",

package/dist/{novel-composer-BCt9g172.d.mts → novel-composer-DhycV9B3.d.mts}

@@ -1,4 +1,4 @@
-import { a as ManuscriptResult, i as ParsedManuscript, t as ComposedManuscript } from "./composed-manuscript-QgIdae8p.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, t as ComposedManuscript } from "./composed-manuscript-C0f3mxKs.mjs";
 import * as v from "valibot";
 //#region src/result/rejection.d.ts
 declare const RejectionSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{

package/dist/plugin.d.mts

@@ -1,3 +1,3 @@
-import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, r as NamespacedId } from "./composed-manuscript-QgIdae8p.mjs";
-import { a as InlineMeasureRequest, c as logicalInlineMeasurer, f as ManuscriptComposer, m as Rejection, n as createNovelComposer, o as InlineMeasurement, p as ManuscriptParser, s as InlineMeasurer } from "./novel-composer-BCt9g172.mjs";
+import { a as ManuscriptResult, i as ParsedManuscript, n as ValidationIssue, r as NamespacedId } from "./composed-manuscript-C0f3mxKs.mjs";
+import { a as InlineMeasureRequest, c as logicalInlineMeasurer, f as ManuscriptComposer, m as Rejection, n as createNovelComposer, o as InlineMeasurement, p as ManuscriptParser, s as InlineMeasurer } from "./novel-composer-DhycV9B3.mjs";
 export { type InlineMeasureRequest, type InlineMeasurement, type InlineMeasurer, type ManuscriptComposer, type ManuscriptParser, ManuscriptResult, NamespacedId, ParsedManuscript, type Rejection, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/dist/plugin.mjs

@@ -1,3 +1,3 @@
 import { c as ManuscriptResult, d as NamespacedId, s as ValidationIssue } from "./question-or-exclamation-spacing-B5o23ZLf.mjs";
-import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-CNBT4TDN.mjs";
+import { a as logicalInlineMeasurer, p as ParsedManuscript, t as createNovelComposer } from "./novel-composer-DRgsEA2s.mjs";
 export { ManuscriptResult, NamespacedId, ParsedManuscript, ValidationIssue, createNovelComposer, logicalInlineMeasurer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sushichan044/kg-core",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Framework-independent parsing, composition, and proofreading for Japanese manuscripts",
   "keywords": [
     "japanese",
@@ -60,7 +60,7 @@
     "publint": "0.3.24",
     "typescript": "7.0.2",
     "unplugin-unused": "0.6.0",
-    "vite-plus": "0.3.0"
+    "vite-plus": "0.3.1"
   },
   "engines": {
     "node": ">=22.12.0"