morphex 0.0.0-stage → 1.0.1

package/dist/index.d.cts

@@ -0,0 +1,257 @@
+/**
+ * Public type surface for morphex.
+ *
+ * The shapes mirror the Java library's `Inflection`, `DecisionSource`, `Countability`,
+ * `CasePolicy`, `Mode` and `UppercasePolicy`, adapted to TypeScript idioms.
+ */
+/** Stable decision stages, in precedence order. */
+declare const INFLECTION_SOURCES: readonly ["OVERRIDE", "LEXICON", "INFERRED", "COMPOUND", "RULE", "FALLBACK"];
+/** Where the reported plural came from. Ordered by precedence. */
+type InflectionSource = (typeof INFLECTION_SOURCES)[number];
+/** Countability metadata for a noun lemma. */
+declare const COUNTABILITIES: readonly ["COUNTABLE", "MASS", "MIXED", "PLURAL_ONLY", "UNKNOWN"];
+type Countability = (typeof COUNTABILITIES)[number];
+/** Preferred-form mode for lemmas with both an anglicized and a classical plural. */
+type Mode = 'ANGLICIZED' | 'CLASSICAL';
+/** Output casing policy. */
+type CasePolicy = 'PRESERVE' | 'LOWERCASE' | 'UPPERCASE';
+/** How an unknown all-uppercase token is interpreted. */
+type UppercasePolicy = 'INFER_INITIALISM' | 'LITERAL';
+/**
+ * Diagnostic result of `analyze()`.
+ *
+ * `stage` is the decision stage (the Java `DecisionSource`); `source` is the stable identifier
+ * for the entry or rule that won (the Java `Inflection.id()`), e.g. `lex:child` or
+ * `rule:default-s`. Every field is always present: a build without full lexical diagnostics
+ * reports `diagnostics: false` and leaves `countability` at `UNKNOWN` rather than `undefined`.
+ */
+interface Inflection {
+    /** The caller's exact input spelling. */
+    readonly input: string;
+    /** The selected plural. */
+    readonly plural: string;
+    /** Other accepted plural forms known for this lemma, in artifact order. */
+    readonly alternatives: readonly string[];
+    /**
+     * True when the spelling alone cannot select one form, for example `die` (game piece versus
+     * stamping tool). The selected plural is still returned.
+     */
+    readonly ambiguous: boolean;
+    /** Decision stage that produced the plural. */
+    readonly stage: InflectionSource;
+    /** Stable identifier of the winning entry or rule. */
+    readonly source: string;
+    readonly countability: Countability;
+    /** True when singular and plural are identical (`sheep`). */
+    readonly invariant: boolean;
+    /** Human-readable explanation of the decision. Empty when there is none. */
+    readonly note: string;
+    /**
+     * True when the backing lexicon supplies complete diagnostics (a full artifact or a
+     * caller-supplied lexicon). False for the bundled delta lexicon and rules-only builds, where
+     * metadata for lemmas outside the shipped delta may be absent.
+     */
+    readonly diagnostics: boolean;
+    /** True when `form` is the selected plural or one of the accepted alternatives. */
+    isAccepted(form: string): boolean;
+}
+/** A single lexical entry as seen by the engine. */
+interface LexiconEntry {
+    /** The artifact's exact lemma spelling (case-sensitive entries rely on this). */
+    readonly lemma: string;
+    /** The lower-cased lookup key. */
+    readonly key: string;
+    /** The lower-cased preferred plural. */
+    readonly plural: string;
+    /** An attested classical plural, or `null` when the entry has none. */
+    readonly classical: string | null;
+    /** Other accepted plural forms, in artifact order. */
+    readonly alternatives: readonly string[];
+    readonly countability: Countability;
+    readonly invariant: boolean;
+    readonly initialism: boolean;
+    readonly caseSensitive: boolean;
+    readonly ambiguous: boolean;
+}
+/** Caller-supplied lexicon entry; missing fields take the documented defaults. */
+interface LexiconEntryInput {
+    readonly lemma: string;
+    readonly plural: string;
+    readonly classical?: string | null;
+    readonly alternatives?: readonly string[];
+    readonly countability?: Countability;
+    readonly invariant?: boolean;
+    readonly initialism?: boolean;
+    readonly caseSensitive?: boolean;
+    readonly ambiguous?: boolean;
+}
+/**
+ * A pluggable lexicon. The bundled delta artifact, the opt-in full artifact, rules-only mode and
+ * caller-supplied data all implement this interface.
+ */
+interface LexiconProvider {
+    readonly kind: 'rules-only' | 'delta' | 'full' | 'custom';
+    /** Number of entries visible to the engine. */
+    readonly size: number;
+    /** True when entries carry complete diagnostics (alternatives, countability, notes). */
+    readonly diagnostics: boolean;
+    /** Returns the entry for a lower-cased key, or `undefined`. */
+    lookup(lower: string): LexiconEntry | undefined;
+    /**
+     * Membership evidence for ordinary-word checks. `undefined` means the provider has no
+     * membership table, which disables uppercase-initialism inference exactly as the Java
+     * rules-only instance does.
+     */
+    isOrdinaryWord(lower: string): boolean | undefined;
+}
+/** A membership table for lower-cased lemmas, independent of the exception artifact. */
+interface MembershipTable {
+    readonly size: number;
+    contains(lower: string): boolean;
+}
+
+/**
+ * Immutable English noun pluralizer, a TypeScript port of the Java `EnglishInflector`.
+ *
+ * Resolution order is fixed: caller override, exact lexical entry, caller-declared initialism,
+ * supported compound, productive spelling rule, then the documented fallback that returns the
+ * input unchanged. Instances are immutable and stateless.
+ */
+
+interface Config {
+    readonly mode: Mode;
+    readonly casePolicy: CasePolicy;
+    readonly overrides: ReadonlyMap<string, string>;
+    readonly initialisms: ReadonlySet<string>;
+    readonly uppercasePolicy: UppercasePolicy;
+    readonly lexicon: LexiconProvider;
+}
+declare class EnglishInflector {
+    #private;
+    /** @internal Instances are created through `standard()` or `builder()`. */
+    constructor(config: Config);
+    /** Shared default instance: anglicized mode, `PRESERVE` casing, bundled delta lexicon. */
+    static standard(): EnglishInflector;
+    static builder(): Builder;
+    get mode(): Mode;
+    get casePolicy(): CasePolicy;
+    get uppercasePolicy(): UppercasePolicy;
+    /** Number of lexical entries visible to this instance (0 for a rules-only build). */
+    get lexiconSize(): number;
+    /**
+     * Returns the plural of a singular noun. With a `count`, returns `noun` unchanged when
+     * `count === 1` and the plural otherwise. This is deliberately a plain count test, not an
+     * absolute-value or locale rule.
+     */
+    pluralize(noun: string, count?: number): string;
+    /** Returns a full diagnostic result. The chosen form is identical to `pluralize(noun)`. */
+    analyze(noun: string): Inflection;
+}
+/** Immutable configuration builder. Every setter returns the builder. */
+declare class Builder {
+    #private;
+    withMode(mode: Mode): this;
+    withCasePolicy(casePolicy: CasePolicy): this;
+    withUppercasePolicy(uppercasePolicy: UppercasePolicy): this;
+    /** Adds an exact, case-sensitive replacement for the whole input spelling. */
+    withOverride(noun: string, plural: string): this;
+    withOverrides(replacements: Readonly<Record<string, string>>): this;
+    /** Declares a token an initialism: it appends `s`, or `es` after a final s. */
+    withInitialism(token: string): this;
+    withInitialisms(tokens: Iterable<string>): this;
+    /** Replaces the bundled lexicon with caller-supplied or custom data. */
+    withLexicon(lexicon: LexiconProvider): this;
+    /** Builds a rules-only instance (no bundled lexicon). */
+    withoutBundledLexicon(): this;
+    build(): EnglishInflector;
+}
+
+/**
+ * Lexicon providers: the packed delta artifact, the packed full artifact, rules-only mode and
+ * caller-supplied data all implement the same `LexiconProvider` interface.
+ *
+ * Two packed formats are emitted, both line-oriented so they can be reviewed in a diff.
+ *
+ * Full artifact (`morphex-lexicon-v1`):
+ *
+ *     morphex-lexicon-v1<TAB>full<TAB><count>
+ *     <lemma><TAB><cut><TAB><append><TAB><classicalCut|-><TAB><classicalAppend|-><TAB><alternatives|-><TAB><countability><TAB><flags>
+ *
+ * Delta artifact (`morphex-delta-v1`): a small table of entries whose edit differs from the
+ * productive rules, followed by sorted key lists for the mass, plural-only and invariant nouns
+ * whose pluralize() answer is "return the input unchanged". Those identity nouns are 90k of the
+ * 147k artifact entries, and a key list stores them without a redundant record per noun.
+ *
+ *     morphex-delta-v1<TAB><edits><TAB><mass><TAB><pluralOnly><TAB><invariant>
+ *     <edit record, full format minus the leading kind>
+ *     <lower-case key>            (mass)
+ *     <lower-case key>            (plural-only)
+ *     <lower-case key>            (invariant)
+ *
+ * Both loaders reject a malformed artifact, an unsorted file, a duplicate key or a bad flag
+ * instead of guessing.
+ */
+
+/** Computes the end-of-token edit that turns `lemma` into `plural` (longest common prefix). */
+declare function deriveEdit(lemma: string, plural: string): readonly [cut: number, append: string];
+/** Rules-only provider: no entries, no membership evidence, no data. */
+declare const RULES_ONLY_LEXICON: LexiconProvider;
+/** Parses the full packed artifact. Throws on malformed, unsorted or duplicate data. */
+declare function parseFullLexicon(packed: string): readonly LexiconEntry[];
+/** Builds the opt-in full provider from a packed full artifact. */
+declare function createFullLexicon(packed: string, membership?: MembershipTable): LexiconProvider;
+/** Builds the bundled delta provider. `pluralize()` needs nothing else. */
+declare function createDeltaLexicon(packed: string, membership?: MembershipTable): LexiconProvider;
+/**
+ * Builds a provider from caller-supplied entries. Duplicate lookup keys are rejected, matching
+ * the bundled-artifact loader.
+ */
+declare function createLexicon(entries: Iterable<LexiconEntryInput>, membership?: MembershipTable): LexiconProvider;
+/** FNV-1a 64-bit, low 32 bits only: identical to the Java membership hash truncated. */
+declare function fnv1aLow32(value: string): number;
+/** Decodes standard base64 without depending on `atob` or Node-specific APIs. */
+declare function decodeBase64(value: string): Uint8Array;
+/** Wraps a base64-encoded, sorted, little-endian `uint32` hash table as a membership table. */
+declare function createMembershipTable(base64: string): MembershipTable;
+
+/**
+ * Default bundled lexicon. The generated module contains the delta artifact: only the entries
+ * whose true answer differs from the three productive rules, plus entries that carry metadata
+ * which changes a decision. `pluralize()` needs nothing else.
+ *
+ * The `morphex/rules` build replaces this module with an empty artifact, so that entry ships no
+ * lexicon data at all.
+ */
+
+declare function defaultLexiconProvider(): LexiconProvider;
+
+/**
+ * Bounded, documented compound support, ported from the Java `CompoundTable`.
+ *
+ * Deliberately small: a suffix match is not proof of a morpheme boundary, so only structures that
+ * were individually reviewed are recognised. A malformed table entry fails fast at module load.
+ */
+/** Whole compound (lower case) to whole plural (lower case). */
+declare const COMPOUND_EXACT: {
+    readonly 'passer-by': "passers-by";
+    readonly 'hanger-on': "hangers-on";
+    readonly 'looker-on': "lookers-on";
+    readonly 'runner-up': "runners-up";
+    readonly 'stand-in': "stand-ins";
+    readonly 'drive-by': "drive-bys";
+    readonly 'tie-in': "tie-ins";
+    readonly 'close-up': "close-ups";
+    readonly 'grown-up': "grown-ups";
+    readonly 'go-between': "go-betweens";
+    readonly 'forget-me-not': "forget-me-nots";
+    readonly 'jack-in-the-box': "jack-in-the-boxes";
+    readonly 'man-of-war': "men-of-war";
+    readonly 'major general': "major generals";
+};
+/**
+ * Validates every table entry. A typo (upper case, missing separator, duplicate membership)
+ * throws, so a malformed table fails the build and the test run instead of silently misfiring.
+ */
+declare function validateCompoundTable(): void;
+
+export { Builder, COMPOUND_EXACT, COUNTABILITIES, type CasePolicy, type Countability, EnglishInflector, INFLECTION_SOURCES, type Inflection, type InflectionSource, type LexiconEntry, type LexiconEntryInput, type LexiconProvider, type MembershipTable, type Mode, RULES_ONLY_LEXICON, type UppercasePolicy, createDeltaLexicon, createFullLexicon, createLexicon, createMembershipTable, decodeBase64, defaultLexiconProvider, deriveEdit, fnv1aLow32, parseFullLexicon, validateCompoundTable };

package/dist/index.d.ts

@@ -0,0 +1,257 @@
+/**
+ * Public type surface for morphex.
+ *
+ * The shapes mirror the Java library's `Inflection`, `DecisionSource`, `Countability`,
+ * `CasePolicy`, `Mode` and `UppercasePolicy`, adapted to TypeScript idioms.
+ */
+/** Stable decision stages, in precedence order. */
+declare const INFLECTION_SOURCES: readonly ["OVERRIDE", "LEXICON", "INFERRED", "COMPOUND", "RULE", "FALLBACK"];
+/** Where the reported plural came from. Ordered by precedence. */
+type InflectionSource = (typeof INFLECTION_SOURCES)[number];
+/** Countability metadata for a noun lemma. */
+declare const COUNTABILITIES: readonly ["COUNTABLE", "MASS", "MIXED", "PLURAL_ONLY", "UNKNOWN"];
+type Countability = (typeof COUNTABILITIES)[number];
+/** Preferred-form mode for lemmas with both an anglicized and a classical plural. */
+type Mode = 'ANGLICIZED' | 'CLASSICAL';
+/** Output casing policy. */
+type CasePolicy = 'PRESERVE' | 'LOWERCASE' | 'UPPERCASE';
+/** How an unknown all-uppercase token is interpreted. */
+type UppercasePolicy = 'INFER_INITIALISM' | 'LITERAL';
+/**
+ * Diagnostic result of `analyze()`.
+ *
+ * `stage` is the decision stage (the Java `DecisionSource`); `source` is the stable identifier
+ * for the entry or rule that won (the Java `Inflection.id()`), e.g. `lex:child` or
+ * `rule:default-s`. Every field is always present: a build without full lexical diagnostics
+ * reports `diagnostics: false` and leaves `countability` at `UNKNOWN` rather than `undefined`.
+ */
+interface Inflection {
+    /** The caller's exact input spelling. */
+    readonly input: string;
+    /** The selected plural. */
+    readonly plural: string;
+    /** Other accepted plural forms known for this lemma, in artifact order. */
+    readonly alternatives: readonly string[];
+    /**
+     * True when the spelling alone cannot select one form, for example `die` (game piece versus
+     * stamping tool). The selected plural is still returned.
+     */
+    readonly ambiguous: boolean;
+    /** Decision stage that produced the plural. */
+    readonly stage: InflectionSource;
+    /** Stable identifier of the winning entry or rule. */
+    readonly source: string;
+    readonly countability: Countability;
+    /** True when singular and plural are identical (`sheep`). */
+    readonly invariant: boolean;
+    /** Human-readable explanation of the decision. Empty when there is none. */
+    readonly note: string;
+    /**
+     * True when the backing lexicon supplies complete diagnostics (a full artifact or a
+     * caller-supplied lexicon). False for the bundled delta lexicon and rules-only builds, where
+     * metadata for lemmas outside the shipped delta may be absent.
+     */
+    readonly diagnostics: boolean;
+    /** True when `form` is the selected plural or one of the accepted alternatives. */
+    isAccepted(form: string): boolean;
+}
+/** A single lexical entry as seen by the engine. */
+interface LexiconEntry {
+    /** The artifact's exact lemma spelling (case-sensitive entries rely on this). */
+    readonly lemma: string;
+    /** The lower-cased lookup key. */
+    readonly key: string;
+    /** The lower-cased preferred plural. */
+    readonly plural: string;
+    /** An attested classical plural, or `null` when the entry has none. */
+    readonly classical: string | null;
+    /** Other accepted plural forms, in artifact order. */
+    readonly alternatives: readonly string[];
+    readonly countability: Countability;
+    readonly invariant: boolean;
+    readonly initialism: boolean;
+    readonly caseSensitive: boolean;
+    readonly ambiguous: boolean;
+}
+/** Caller-supplied lexicon entry; missing fields take the documented defaults. */
+interface LexiconEntryInput {
+    readonly lemma: string;
+    readonly plural: string;
+    readonly classical?: string | null;
+    readonly alternatives?: readonly string[];
+    readonly countability?: Countability;
+    readonly invariant?: boolean;
+    readonly initialism?: boolean;
+    readonly caseSensitive?: boolean;
+    readonly ambiguous?: boolean;
+}
+/**
+ * A pluggable lexicon. The bundled delta artifact, the opt-in full artifact, rules-only mode and
+ * caller-supplied data all implement this interface.
+ */
+interface LexiconProvider {
+    readonly kind: 'rules-only' | 'delta' | 'full' | 'custom';
+    /** Number of entries visible to the engine. */
+    readonly size: number;
+    /** True when entries carry complete diagnostics (alternatives, countability, notes). */
+    readonly diagnostics: boolean;
+    /** Returns the entry for a lower-cased key, or `undefined`. */
+    lookup(lower: string): LexiconEntry | undefined;
+    /**
+     * Membership evidence for ordinary-word checks. `undefined` means the provider has no
+     * membership table, which disables uppercase-initialism inference exactly as the Java
+     * rules-only instance does.
+     */
+    isOrdinaryWord(lower: string): boolean | undefined;
+}
+/** A membership table for lower-cased lemmas, independent of the exception artifact. */
+interface MembershipTable {
+    readonly size: number;
+    contains(lower: string): boolean;
+}
+
+/**
+ * Immutable English noun pluralizer, a TypeScript port of the Java `EnglishInflector`.
+ *
+ * Resolution order is fixed: caller override, exact lexical entry, caller-declared initialism,
+ * supported compound, productive spelling rule, then the documented fallback that returns the
+ * input unchanged. Instances are immutable and stateless.
+ */
+
+interface Config {
+    readonly mode: Mode;
+    readonly casePolicy: CasePolicy;
+    readonly overrides: ReadonlyMap<string, string>;
+    readonly initialisms: ReadonlySet<string>;
+    readonly uppercasePolicy: UppercasePolicy;
+    readonly lexicon: LexiconProvider;
+}
+declare class EnglishInflector {
+    #private;
+    /** @internal Instances are created through `standard()` or `builder()`. */
+    constructor(config: Config);
+    /** Shared default instance: anglicized mode, `PRESERVE` casing, bundled delta lexicon. */
+    static standard(): EnglishInflector;
+    static builder(): Builder;
+    get mode(): Mode;
+    get casePolicy(): CasePolicy;
+    get uppercasePolicy(): UppercasePolicy;
+    /** Number of lexical entries visible to this instance (0 for a rules-only build). */
+    get lexiconSize(): number;
+    /**
+     * Returns the plural of a singular noun. With a `count`, returns `noun` unchanged when
+     * `count === 1` and the plural otherwise. This is deliberately a plain count test, not an
+     * absolute-value or locale rule.
+     */
+    pluralize(noun: string, count?: number): string;
+    /** Returns a full diagnostic result. The chosen form is identical to `pluralize(noun)`. */
+    analyze(noun: string): Inflection;
+}
+/** Immutable configuration builder. Every setter returns the builder. */
+declare class Builder {
+    #private;
+    withMode(mode: Mode): this;
+    withCasePolicy(casePolicy: CasePolicy): this;
+    withUppercasePolicy(uppercasePolicy: UppercasePolicy): this;
+    /** Adds an exact, case-sensitive replacement for the whole input spelling. */
+    withOverride(noun: string, plural: string): this;
+    withOverrides(replacements: Readonly<Record<string, string>>): this;
+    /** Declares a token an initialism: it appends `s`, or `es` after a final s. */
+    withInitialism(token: string): this;
+    withInitialisms(tokens: Iterable<string>): this;
+    /** Replaces the bundled lexicon with caller-supplied or custom data. */
+    withLexicon(lexicon: LexiconProvider): this;
+    /** Builds a rules-only instance (no bundled lexicon). */
+    withoutBundledLexicon(): this;
+    build(): EnglishInflector;
+}
+
+/**
+ * Lexicon providers: the packed delta artifact, the packed full artifact, rules-only mode and
+ * caller-supplied data all implement the same `LexiconProvider` interface.
+ *
+ * Two packed formats are emitted, both line-oriented so they can be reviewed in a diff.
+ *
+ * Full artifact (`morphex-lexicon-v1`):
+ *
+ *     morphex-lexicon-v1<TAB>full<TAB><count>
+ *     <lemma><TAB><cut><TAB><append><TAB><classicalCut|-><TAB><classicalAppend|-><TAB><alternatives|-><TAB><countability><TAB><flags>
+ *
+ * Delta artifact (`morphex-delta-v1`): a small table of entries whose edit differs from the
+ * productive rules, followed by sorted key lists for the mass, plural-only and invariant nouns
+ * whose pluralize() answer is "return the input unchanged". Those identity nouns are 90k of the
+ * 147k artifact entries, and a key list stores them without a redundant record per noun.
+ *
+ *     morphex-delta-v1<TAB><edits><TAB><mass><TAB><pluralOnly><TAB><invariant>
+ *     <edit record, full format minus the leading kind>
+ *     <lower-case key>            (mass)
+ *     <lower-case key>            (plural-only)
+ *     <lower-case key>            (invariant)
+ *
+ * Both loaders reject a malformed artifact, an unsorted file, a duplicate key or a bad flag
+ * instead of guessing.
+ */
+
+/** Computes the end-of-token edit that turns `lemma` into `plural` (longest common prefix). */
+declare function deriveEdit(lemma: string, plural: string): readonly [cut: number, append: string];
+/** Rules-only provider: no entries, no membership evidence, no data. */
+declare const RULES_ONLY_LEXICON: LexiconProvider;
+/** Parses the full packed artifact. Throws on malformed, unsorted or duplicate data. */
+declare function parseFullLexicon(packed: string): readonly LexiconEntry[];
+/** Builds the opt-in full provider from a packed full artifact. */
+declare function createFullLexicon(packed: string, membership?: MembershipTable): LexiconProvider;
+/** Builds the bundled delta provider. `pluralize()` needs nothing else. */
+declare function createDeltaLexicon(packed: string, membership?: MembershipTable): LexiconProvider;
+/**
+ * Builds a provider from caller-supplied entries. Duplicate lookup keys are rejected, matching
+ * the bundled-artifact loader.
+ */
+declare function createLexicon(entries: Iterable<LexiconEntryInput>, membership?: MembershipTable): LexiconProvider;
+/** FNV-1a 64-bit, low 32 bits only: identical to the Java membership hash truncated. */
+declare function fnv1aLow32(value: string): number;
+/** Decodes standard base64 without depending on `atob` or Node-specific APIs. */
+declare function decodeBase64(value: string): Uint8Array;
+/** Wraps a base64-encoded, sorted, little-endian `uint32` hash table as a membership table. */
+declare function createMembershipTable(base64: string): MembershipTable;
+
+/**
+ * Default bundled lexicon. The generated module contains the delta artifact: only the entries
+ * whose true answer differs from the three productive rules, plus entries that carry metadata
+ * which changes a decision. `pluralize()` needs nothing else.
+ *
+ * The `morphex/rules` build replaces this module with an empty artifact, so that entry ships no
+ * lexicon data at all.
+ */
+
+declare function defaultLexiconProvider(): LexiconProvider;
+
+/**
+ * Bounded, documented compound support, ported from the Java `CompoundTable`.
+ *
+ * Deliberately small: a suffix match is not proof of a morpheme boundary, so only structures that
+ * were individually reviewed are recognised. A malformed table entry fails fast at module load.
+ */
+/** Whole compound (lower case) to whole plural (lower case). */
+declare const COMPOUND_EXACT: {
+    readonly 'passer-by': "passers-by";
+    readonly 'hanger-on': "hangers-on";
+    readonly 'looker-on': "lookers-on";
+    readonly 'runner-up': "runners-up";
+    readonly 'stand-in': "stand-ins";
+    readonly 'drive-by': "drive-bys";
+    readonly 'tie-in': "tie-ins";
+    readonly 'close-up': "close-ups";
+    readonly 'grown-up': "grown-ups";
+    readonly 'go-between': "go-betweens";
+    readonly 'forget-me-not': "forget-me-nots";
+    readonly 'jack-in-the-box': "jack-in-the-boxes";
+    readonly 'man-of-war': "men-of-war";
+    readonly 'major general': "major generals";
+};
+/**
+ * Validates every table entry. A typo (upper case, missing separator, duplicate membership)
+ * throws, so a malformed table fails the build and the test run instead of silently misfiring.
+ */
+declare function validateCompoundTable(): void;
+
+export { Builder, COMPOUND_EXACT, COUNTABILITIES, type CasePolicy, type Countability, EnglishInflector, INFLECTION_SOURCES, type Inflection, type InflectionSource, type LexiconEntry, type LexiconEntryInput, type LexiconProvider, type MembershipTable, type Mode, RULES_ONLY_LEXICON, type UppercasePolicy, createDeltaLexicon, createFullLexicon, createLexicon, createMembershipTable, decodeBase64, defaultLexiconProvider, deriveEdit, fnv1aLow32, parseFullLexicon, validateCompoundTable };