pravapis 0.1.0

package/dist/pipeline-CQ31DzWB.d.ts

@@ -0,0 +1,155 @@
+import { b as CaseFormsRow, D as DirectedPairs, O as Orthography, S as StemRow, A as Alternation, R as RuleJson, F as FunctionWordRow, d as CoreData, a as ConversionResult, T as TokenExplanation } from './types-wqNurkip.js';
+
+declare class CaseForms {
+    private readonly table;
+    private readonly dativeLocative;
+    constructor(table: ReadonlyMap<string, CaseFormsRow>, dativeLocative?: ReadonlySet<string>);
+    static fromRecord(rows: Readonly<Record<string, CaseFormsRow>>, dativeLocative?: ReadonlySet<string>): CaseForms;
+    has(word: string): boolean;
+    /** [lowercase target, reason] for `word` after `previous`, or null if not listed. */
+    choose(word: string, previous: string | null): [string, string] | null;
+}
+
+declare class Lexicon {
+    private readonly exceptions;
+    private readonly loanwords;
+    private readonly properNouns;
+    constructor(exceptions: DirectedPairs, loanwords: DirectedPairs, properNouns: DirectedPairs);
+    /** Exact-key lookup (keys are lowercase). `direction` is the target orthography. */
+    lookup(word: string, direction: Orthography): string | null;
+    lookupCi(word: string, direction: Orthography): string | null;
+    /** Is `word` explicitly listed as spelled the same in both orthographies? */
+    isIdentity(word: string): boolean;
+}
+
+type WordClass = StemRow["class"];
+/** Where a known stem was found in a word, and what it licenses. Mirrors
+ * pravapis.lexicon.stems.StemMatch. */
+interface StemMatch {
+    stem: string;
+    cls: WordClass;
+    alternations: readonly Alternation[];
+    start: number;
+    end: number;
+    target: string | null;
+    /** Length of the word this match was resolved against, or -1 for an anchored match
+     * (which is always resolved at [0, stem.length) and so never goes stale). A rule
+     * that changes the word's length after resolution invalidates a nonnegative one —
+     * see spansStill(). */
+    wordLen: number;
+}
+declare class StemIndex {
+    private readonly anchoredSorted;
+    private readonly byAnchoredStem;
+    private readonly maxAnchoredLen;
+    /** Longest first, so the leftmost-position scan in `match()` prefers the longest
+     * stem among several that start at the same position — the same preference
+     * `regex.compile("|".join(...))`'s ordered alternation gives the Python side. */
+    private readonly unanchoredByLenDesc;
+    constructor(rows: readonly StemRow[]);
+    static empty(): StemIndex;
+    get size(): number;
+    /** Exact membership in the sorted anchored-stem array, by binary search. */
+    private hasAnchored;
+    /** The longest anchored stem that prefixes `w`, tried longest-first so the first
+     * hit is already the answer — no need to scan the rest. One binary search per
+     * candidate length, capped at the longest stem in the inventory: at most
+     * `maxAnchoredLen` searches of a ~200-entry array, not a measurable cost. */
+    private matchAnchored;
+    /** The leftmost position in `w` where any unanchored stem occurs, preferring the
+     * longest stem at that position — mirrors `regex.Pattern.search` over an
+     * alternation of literals ordered longest-first. Only 8 unanchored stems exist
+     * today (see data/lexicon/stems/stems.tsv), so a plain nested scan costs nothing;
+     * this is not the array a bigger inventory would want. */
+    private matchUnanchored;
+    /** The longest known stem in `word`; anchored wins ties (an unanchored match only
+     * overrides when it is strictly longer) — see data/schemas/stems.schema.json,
+     * "Longest match wins... anchored beating unanchored on a tie". */
+    match(word: string): StemMatch | null;
+}
+
+interface RuleTraceEntry {
+    ruleId: string;
+    before: string;
+    after: string;
+}
+declare class RuleEngine {
+    private readonly rules;
+    private readonly byDirection;
+    private readonly repeatRules;
+    private readonly byId;
+    private readonly stems;
+    readonly includeOptional: boolean;
+    constructor(rules: readonly RuleJson[], stems: ReadonlyMap<Orthography, StemIndex>, includeOptional?: boolean);
+    withOptional(include: boolean): RuleEngine;
+    stemMatch(word: string, direction: Orthography): StemMatch | null;
+    get(ruleId: string): RuleJson | undefined;
+    citationFor(ruleId: string): string | null;
+    private firesOn;
+    private transform;
+    /** Apply every rule for `direction` and record the ones that changed the word. */
+    explain(word: string, direction: Orthography): RuleTraceEntry[];
+    apply(word: string, direction: Orthography): [string, string[]];
+}
+
+declare class FunctionWords {
+    readonly particlesN2t: ReadonlyMap<string, string>;
+    readonly particlesT2n: ReadonlyMap<string, string>;
+    readonly softeningPrepositions: ReadonlySet<string>;
+    readonly clitics: ReadonlySet<string>;
+    /** Longer stems must not be shadowed by a shorter one that happens to precede it in
+     * iteration order, so this is checked with an explicit "does any stem prefix the
+     * word" scan, not `Array.prototype.includes`. */
+    readonly stressedInitialU: readonly string[];
+    readonly dativeLocativePrepositions: ReadonlySet<string>;
+    constructor(rows: readonly FunctionWordRow[]);
+    static empty(): FunctionWords;
+    hasStressedInitialUPrefix(lowerWord: string): boolean;
+}
+
+declare class MentSuffix {
+    private readonly forms;
+    constructor(lemmas: readonly string[]);
+    static empty(): MentSuffix;
+    /** Does this word carry a -мент base, and so inherit its э? Asked of the word as it
+     * *arrived*, never of a partly converted one. */
+    applies(narkamaukaForm: string): boolean;
+    static toHard(word: string): string;
+    static toSoft(word: string): string;
+}
+
+declare class Converter {
+    private readonly lexicon;
+    private readonly engine;
+    private readonly caseForms;
+    private readonly functionWords;
+    private readonly mentSuffix;
+    private readonly cache;
+    private readonly citationCache;
+    private readonly contextSensitiveWords;
+    constructor(lexicon: Lexicon, engine: RuleEngine, caseForms: CaseForms, functionWords: FunctionWords, mentSuffix: MentSuffix);
+    /** `properNouns` defaults to empty: proper-noun lookups then simply miss the
+     * lexicon and fall through to the rule engine / passthrough, same as any other
+     * unlisted word. Pass names.json's table (see js/src/names.ts) to include it —
+     * loaded lazily and separately because it is one of the largest lexicon tables and
+     * most conversions never touch a proper noun. */
+    static fromCore(core: CoreData, properNouns?: CoreData["exceptions"]): Converter;
+    private isAmbiguous;
+    citationFor(ruleId: string | null): string | null;
+    private contextFor;
+    private lookupStep;
+    private resolve;
+    private resolveCached;
+    private nextTarget;
+    private resolveClitic;
+    private resolveHyphenated;
+    private cascade;
+    private initialU;
+    private withOutputSpans;
+    convert(text: string, direction: Orthography, unresolvedRequested?: boolean): ConversionResult;
+    explain(text: string, direction: Orthography): TokenExplanation[];
+    private explanationFor;
+    private tracesFor;
+}
+
+export { Converter as C };

package/dist/pipeline-T0FQH27h.d.cts

@@ -0,0 +1,155 @@
+import { b as CaseFormsRow, D as DirectedPairs, O as Orthography, S as StemRow, A as Alternation, R as RuleJson, F as FunctionWordRow, d as CoreData, a as ConversionResult, T as TokenExplanation } from './types-wqNurkip.cjs';
+
+declare class CaseForms {
+    private readonly table;
+    private readonly dativeLocative;
+    constructor(table: ReadonlyMap<string, CaseFormsRow>, dativeLocative?: ReadonlySet<string>);
+    static fromRecord(rows: Readonly<Record<string, CaseFormsRow>>, dativeLocative?: ReadonlySet<string>): CaseForms;
+    has(word: string): boolean;
+    /** [lowercase target, reason] for `word` after `previous`, or null if not listed. */
+    choose(word: string, previous: string | null): [string, string] | null;
+}
+
+declare class Lexicon {
+    private readonly exceptions;
+    private readonly loanwords;
+    private readonly properNouns;
+    constructor(exceptions: DirectedPairs, loanwords: DirectedPairs, properNouns: DirectedPairs);
+    /** Exact-key lookup (keys are lowercase). `direction` is the target orthography. */
+    lookup(word: string, direction: Orthography): string | null;
+    lookupCi(word: string, direction: Orthography): string | null;
+    /** Is `word` explicitly listed as spelled the same in both orthographies? */
+    isIdentity(word: string): boolean;
+}
+
+type WordClass = StemRow["class"];
+/** Where a known stem was found in a word, and what it licenses. Mirrors
+ * pravapis.lexicon.stems.StemMatch. */
+interface StemMatch {
+    stem: string;
+    cls: WordClass;
+    alternations: readonly Alternation[];
+    start: number;
+    end: number;
+    target: string | null;
+    /** Length of the word this match was resolved against, or -1 for an anchored match
+     * (which is always resolved at [0, stem.length) and so never goes stale). A rule
+     * that changes the word's length after resolution invalidates a nonnegative one —
+     * see spansStill(). */
+    wordLen: number;
+}
+declare class StemIndex {
+    private readonly anchoredSorted;
+    private readonly byAnchoredStem;
+    private readonly maxAnchoredLen;
+    /** Longest first, so the leftmost-position scan in `match()` prefers the longest
+     * stem among several that start at the same position — the same preference
+     * `regex.compile("|".join(...))`'s ordered alternation gives the Python side. */
+    private readonly unanchoredByLenDesc;
+    constructor(rows: readonly StemRow[]);
+    static empty(): StemIndex;
+    get size(): number;
+    /** Exact membership in the sorted anchored-stem array, by binary search. */
+    private hasAnchored;
+    /** The longest anchored stem that prefixes `w`, tried longest-first so the first
+     * hit is already the answer — no need to scan the rest. One binary search per
+     * candidate length, capped at the longest stem in the inventory: at most
+     * `maxAnchoredLen` searches of a ~200-entry array, not a measurable cost. */
+    private matchAnchored;
+    /** The leftmost position in `w` where any unanchored stem occurs, preferring the
+     * longest stem at that position — mirrors `regex.Pattern.search` over an
+     * alternation of literals ordered longest-first. Only 8 unanchored stems exist
+     * today (see data/lexicon/stems/stems.tsv), so a plain nested scan costs nothing;
+     * this is not the array a bigger inventory would want. */
+    private matchUnanchored;
+    /** The longest known stem in `word`; anchored wins ties (an unanchored match only
+     * overrides when it is strictly longer) — see data/schemas/stems.schema.json,
+     * "Longest match wins... anchored beating unanchored on a tie". */
+    match(word: string): StemMatch | null;
+}
+
+interface RuleTraceEntry {
+    ruleId: string;
+    before: string;
+    after: string;
+}
+declare class RuleEngine {
+    private readonly rules;
+    private readonly byDirection;
+    private readonly repeatRules;
+    private readonly byId;
+    private readonly stems;
+    readonly includeOptional: boolean;
+    constructor(rules: readonly RuleJson[], stems: ReadonlyMap<Orthography, StemIndex>, includeOptional?: boolean);
+    withOptional(include: boolean): RuleEngine;
+    stemMatch(word: string, direction: Orthography): StemMatch | null;
+    get(ruleId: string): RuleJson | undefined;
+    citationFor(ruleId: string): string | null;
+    private firesOn;
+    private transform;
+    /** Apply every rule for `direction` and record the ones that changed the word. */
+    explain(word: string, direction: Orthography): RuleTraceEntry[];
+    apply(word: string, direction: Orthography): [string, string[]];
+}
+
+declare class FunctionWords {
+    readonly particlesN2t: ReadonlyMap<string, string>;
+    readonly particlesT2n: ReadonlyMap<string, string>;
+    readonly softeningPrepositions: ReadonlySet<string>;
+    readonly clitics: ReadonlySet<string>;
+    /** Longer stems must not be shadowed by a shorter one that happens to precede it in
+     * iteration order, so this is checked with an explicit "does any stem prefix the
+     * word" scan, not `Array.prototype.includes`. */
+    readonly stressedInitialU: readonly string[];
+    readonly dativeLocativePrepositions: ReadonlySet<string>;
+    constructor(rows: readonly FunctionWordRow[]);
+    static empty(): FunctionWords;
+    hasStressedInitialUPrefix(lowerWord: string): boolean;
+}
+
+declare class MentSuffix {
+    private readonly forms;
+    constructor(lemmas: readonly string[]);
+    static empty(): MentSuffix;
+    /** Does this word carry a -мент base, and so inherit its э? Asked of the word as it
+     * *arrived*, never of a partly converted one. */
+    applies(narkamaukaForm: string): boolean;
+    static toHard(word: string): string;
+    static toSoft(word: string): string;
+}
+
+declare class Converter {
+    private readonly lexicon;
+    private readonly engine;
+    private readonly caseForms;
+    private readonly functionWords;
+    private readonly mentSuffix;
+    private readonly cache;
+    private readonly citationCache;
+    private readonly contextSensitiveWords;
+    constructor(lexicon: Lexicon, engine: RuleEngine, caseForms: CaseForms, functionWords: FunctionWords, mentSuffix: MentSuffix);
+    /** `properNouns` defaults to empty: proper-noun lookups then simply miss the
+     * lexicon and fall through to the rule engine / passthrough, same as any other
+     * unlisted word. Pass names.json's table (see js/src/names.ts) to include it —
+     * loaded lazily and separately because it is one of the largest lexicon tables and
+     * most conversions never touch a proper noun. */
+    static fromCore(core: CoreData, properNouns?: CoreData["exceptions"]): Converter;
+    private isAmbiguous;
+    citationFor(ruleId: string | null): string | null;
+    private contextFor;
+    private lookupStep;
+    private resolve;
+    private resolveCached;
+    private nextTarget;
+    private resolveClitic;
+    private resolveHyphenated;
+    private cascade;
+    private initialU;
+    private withOutputSpans;
+    convert(text: string, direction: Orthography, unresolvedRequested?: boolean): ConversionResult;
+    explain(text: string, direction: Orthography): TokenExplanation[];
+    private explanationFor;
+    private tracesFor;
+}
+
+export { Converter as C };