@sushichan044/kg-core 0.6.5 → 0.8.0

package/dist/lint.d.mts

@@ -0,0 +1,461 @@
+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 * 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<{
+  kind: "InvalidRuleOptions";
+  ruleId: string;
+  option: string;
+  issues: readonly ValidationIssue[];
+}>;
+declare const InvalidRuleOptions: {
+  readonly describe: (error: InvalidRuleOptions) => string;
+};
+//#endregion
+//#region src/proofreading/proofread-error.d.ts
+/**
+ * Everything that can go wrong while running a set of rules over a manuscript.
+ */
+type ProofreadError = Readonly<{
+  kind: "InvalidRuleId";
+  ruleId: string;
+}> | Readonly<{
+  kind: "DuplicateRuleId";
+  ruleId: NamespacedId;
+}> | Readonly<{
+  kind: "InvalidRuleMetadata";
+  ruleId: NamespacedId;
+  issues: readonly ValidationIssue[];
+}> | Readonly<{
+  kind: "InvalidReport";
+  ruleId: NamespacedId;
+  issues: readonly ValidationIssue[];
+}> | Readonly<{
+  kind: "UnknownMessageId";
+  ruleId: NamespacedId;
+  messageId: string;
+}> | Readonly<{
+  kind: "RuleThrew";
+  ruleId: NamespacedId;
+  cause: unknown;
+}>;
+declare const ProofreadError: {
+  /**
+   * Human-readable rendering. Branch on `kind` instead when the caller needs to react.
+   */
+  readonly describe: (error: ProofreadError) => string;
+};
+//#endregion
+//#region src/proofreading/proofreading-report.d.ts
+declare const ProofreadingReportSchema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly range: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+    readonly source: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+      readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+    }, undefined>, v.ReadonlyAction<{
+      start: number;
+      end: number;
+    }>]>, v.CheckAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "SourceRange">]>;
+    readonly display: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+      readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+    }, undefined>, v.ReadonlyAction<{
+      start: number;
+      end: number;
+    }>]>, v.CheckAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "DisplayRange">]>;
+    readonly graphemes: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+      readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+    }, undefined>, v.ReadonlyAction<{
+      start: number;
+      end: number;
+    }>]>, v.CheckAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+      start: number;
+      end: number;
+    }>, "GraphemeRange">]>;
+  }, undefined>, v.ReadonlyAction<{
+    source: Readonly<{
+      start: number;
+      end: number;
+    }> & v.Brand<"SourceRange">;
+    display: Readonly<{
+      start: number;
+      end: number;
+    }> & v.Brand<"DisplayRange">;
+    graphemes: Readonly<{
+      start: number;
+      end: number;
+    }> & v.Brand<"GraphemeRange">;
+  }>]>;
+  readonly messageId: v.StringSchema<undefined>;
+  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<{
+      start: number;
+      end: number;
+    }> & v.Brand<"SourceRange">;
+    display: Readonly<{
+      start: number;
+      end: number;
+    }> & v.Brand<"DisplayRange">;
+    graphemes: Readonly<{
+      start: number;
+      end: number;
+    }> & v.Brand<"GraphemeRange">;
+  }>;
+  messageId: string;
+  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
+ * formatting text itself, so the same rule can be presented in any language.
+ */
+type ProofreadingReport = v.InferOutput<typeof ProofreadingReportSchema>;
+declare const ProofreadingReport: {
+  readonly schema: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+    readonly range: v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+      readonly source: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+        readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+        readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      }, undefined>, v.ReadonlyAction<{
+        start: number;
+        end: number;
+      }>]>, v.CheckAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "SourceRange">]>;
+      readonly display: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+        readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+        readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      }, undefined>, v.ReadonlyAction<{
+        start: number;
+        end: number;
+      }>]>, v.CheckAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "DisplayRange">]>;
+      readonly graphemes: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+        readonly start: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+        readonly end: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.FiniteAction<number, undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+      }, undefined>, v.ReadonlyAction<{
+        start: number;
+        end: number;
+      }>]>, v.CheckAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "range end must not precede its start">]>, v.BrandAction<Readonly<{
+        start: number;
+        end: number;
+      }>, "GraphemeRange">]>;
+    }, undefined>, v.ReadonlyAction<{
+      source: Readonly<{
+        start: number;
+        end: number;
+      }> & v.Brand<"SourceRange">;
+      display: Readonly<{
+        start: number;
+        end: number;
+      }> & v.Brand<"DisplayRange">;
+      graphemes: Readonly<{
+        start: number;
+        end: number;
+      }> & v.Brand<"GraphemeRange">;
+    }>]>;
+    readonly messageId: v.StringSchema<undefined>;
+    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<{
+        start: number;
+        end: number;
+      }> & v.Brand<"SourceRange">;
+      display: Readonly<{
+        start: number;
+        end: number;
+      }> & v.Brand<"DisplayRange">;
+      graphemes: Readonly<{
+        start: number;
+        end: number;
+      }> & v.Brand<"GraphemeRange">;
+    }>;
+    messageId: string;
+    data?: Readonly<{
+      [x: string]: string | number;
+    }> | undefined;
+    severity?: "error" | "warning" | undefined;
+  }>]>;
+};
+//#endregion
+//#region src/proofreading/proofreading-rule-context.d.ts
+/**
+ * Handed to a rule for the duration of one check; the only way a rule emits findings.
+ */
+type ProofreadingRuleContext = Readonly<{
+  report: (report: ProofreadingReport) => void;
+}>;
+//#endregion
+//#region src/proofreading/proofreading-rule.d.ts
+declare const ProofreadingRuleMessagesSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, v.ReadonlyAction<{
+  [x: string]: string;
+}>]>;
+/**
+ * Message templates the rule can name in a report, keyed by message ID.
+ */
+type ProofreadingRuleMessages = v.InferOutput<typeof ProofreadingRuleMessagesSchema>;
+declare const ProofreadingRuleMetaSchema: 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<{
+    [x: string]: string;
+  }>]>;
+}, undefined>, v.ReadonlyAction<{
+  id: string;
+  readonly messages: Readonly<{
+    [x: string]: string;
+  }>;
+}>]>;
+type ProofreadingRuleMeta = v.InferOutput<typeof ProofreadingRuleMetaSchema>;
+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<{
+      [x: string]: string;
+    }>]>;
+  }, undefined>, v.ReadonlyAction<{
+    id: string;
+    readonly messages: Readonly<{
+      [x: string]: string;
+    }>;
+  }>]>;
+  readonly messagesSchema: v.SchemaWithPipe<readonly [v.RecordSchema<v.StringSchema<undefined>, v.StringSchema<undefined>, undefined>, v.ReadonlyAction<{
+    [x: string]: string;
+  }>]>;
+};
+/**
+ * A rule that only needs the parsed manuscript. The `kind` sits on the rule itself, not inside
+ * `meta`, so the runner narrows to the right `check` signature without a cast.
+ */
+type ParsedProofreadingRule = Readonly<{
+  kind: "parsed";
+  meta: ProofreadingRuleMeta;
+  check: (manuscript: ParsedManuscript, context: ProofreadingRuleContext) => void;
+}>;
+/**
+ * A rule that needs the composed manuscript, for findings that depend on placement.
+ */
+type ComposedProofreadingRule<TComposed extends ComposedManuscript = ComposedManuscript> = Readonly<{
+  kind: "composed";
+  meta: ProofreadingRuleMeta;
+  check: (manuscript: TComposed, context: ProofreadingRuleContext) => void;
+}>;
+type ProofreadingRule = ParsedProofreadingRule | ComposedProofreadingRule;
+//#endregion
+//#region src/proofreading/proofread-manuscript.d.ts
+/**
+ * `TRule` is deliberately unconstrained: a rule written for one composer's manuscript is not a
+ * `ProofreadingRule`, because accepting a narrower manuscript makes it a narrower function. The
+ * overloads below pin down which rules each call actually accepts.
+ */
+type ProofreadOptions<TRule> = Readonly<{
+  rules: readonly TRule[];
+}>;
+type Diagnostics = readonly ManuscriptDiagnostic[];
+type ProofreadOutcome = ManuscriptResult<Diagnostics, ProofreadError>;
+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;
+//#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">]>;
+/**
+ * One word in both of its spellings — `出来る` against `できる`. Japanese editing names the two choices
+ * rather than the two forms: writing a word in kanji is 閉じる and writing it in kana is 開く, which is
+ * where the field names come from. Which one a work prefers is its own house style; using both
+ * within one work is 表記ゆれ.
+ */
+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
+/**
+ * Halfwidth and fullwidth Latin letters (半角英字 and 全角英字) in one work. In vertical writing the two
+ * are set differently — a fullwidth letter stands upright on its own em, a halfwidth one joins a
+ * run that may turn sideways — so mixing them is 表記ゆれ the reader can see. Which one a work uses is
+ * its own choice, hence a warning.
+ */
+declare const consistentLatinWidthRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/consistent-numeral-width.d.ts
+/**
+ * Halfwidth and fullwidth digits (半角数字 and 全角数字) in one work. A fullwidth digit stands upright on
+ * its own em; a halfwidth pair sets as 縦中横 inside one. Mixing them is 表記ゆれ, but which one a work
+ * uses is its own choice, hence a warning.
+ */
+declare const consistentNumeralWidthRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/dash.d.ts
+declare const DashCharacterSchema: v.PicklistSchema<readonly ["―", "—", "─"], undefined>;
+type DashCharacter = v.InferOutput<typeof DashCharacterSchema>;
+type DashOptions = Readonly<{
+  preferred?: DashCharacter;
+}>;
+declare const dashRule: () => ParsedProofreadingRule;
+declare function createDashRule(options?: DashOptions): ManuscriptResult<ParsedProofreadingRule, InvalidRuleOptions>;
+//#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 the ellipsis (三点リーダー) `…`. Only the real character is set on its own em and pairs
+ * into a 2倍リーダ; a run of ASCII periods is neither. Runs of `。` and `・` are left to the rules that
+ * already count them, so one substitute is never reported twice.
+ */
+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;
+//#endregion
+//#region src/proofreading/rules/fullwidth-japanese-punctuation.d.ts
+/**
+ * Halfwidth punctuation (約物) where Japanese prose calls for the fullwidth form. Japanese
+ * punctuation is designed to occupy one em, and the composer's spacing rules are stated in those
+ * terms, so a halfwidth form neither lands on the grid nor picks up the spacing its character class
+ * calls for.
+ *
+ * The three checks differ in how much the surroundings decide the answer, which is why only the
+ * first is decisive on its own.
+ */
+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>;
+//#endregion
+//#region src/proofreading/rules/minus-before-number.d.ts
+/**
+ * A minus sign (U+2212, JLReq 演算記号) with no number after it. It is almost always a mistyped dash or
+ * prolonged sound mark, which look alike but belong to different character classes and so are
+ * spaced and broken differently.
+ */
+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;
+//#endregion
+//#region src/proofreading/rules/no-consecutive-punctuation.d.ts
+/**
+ * A repeated full stop or comma (句読点 — JLReq 句点類 cl-06 and 読点類 cl-07). Each ends its clause once,
+ * so a run of them is not punctuation at all: it is a sentence trailing off, which Japanese prose
+ * writes with `…`.
+ */
+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>;
+//#endregion
+//#region src/proofreading/rules/punctuation-before-closing-quote.d.ts
+/**
+ * A full stop or comma immediately before a closing bracket (終わり括弧類). The bracket already closes
+ * the quotation, and both characters are set on a half em, so the pair reads as a gap in the line
+ * rather than as punctuation. Japanese practice drops the punctuation and keeps the bracket.
+ */
+declare const punctuationBeforeClosingQuoteRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/space-after-question-or-exclamation.d.ts
+/**
+ * The gap that follows every run of ！ or ？ (区切り約物, JLReq 3.1.6). A dividing punctuation mark ends a
+ * sentence without a full stop, so a full em of white stands in for the one a 句点 would have
+ * carried. A run at the end of a line or right before a closing bracket is already separated from
+ * what follows and needs no gap; anywhere else it takes exactly one ideographic space.
+ */
+declare const spaceAfterQuestionOrExclamationRule: () => ParsedProofreadingRule;
+//#endregion
+//#region src/proofreading/rules/variant-character.d.ts
+/**
+ * Variant forms of a character (異体字) and the selectors that request them (字形選択子 / IVS). Whether
+ * such a form survives depends on the font and the platform, so a manuscript that relies on one
+ * will not read the same everywhere it is published.
+ *
+ * Scans the source rather than the display text: notation removal must not hide a variant.
+ */
+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 };