@finbheara/domain 0.0.0-stage → 0.2.0

package/dist/tune.js

@@ -0,0 +1,23 @@
+import {
+  SET_MIN_SPEED2,
+  PLAUSIBLE_SET_TEMPO_MAX2,
+  TUNE_NODES2,
+  allTunes2,
+  tuneById2,
+  tempoLegal2,
+  settingAt2,
+  tune2,
+  tuneRelation2
+} from "./chunks/place-kr42294h.js";
+import"./chunks/place-g6yw4cq6.js";
+export {
+  PLAUSIBLE_SET_TEMPO_MAX2 as PLAUSIBLE_SET_TEMPO_MAX,
+  SET_MIN_SPEED2 as SET_MIN_SPEED,
+  TUNE_NODES2 as TUNE_NODES,
+  allTunes2 as allTunes,
+  settingAt2 as settingAt,
+  tempoLegal2 as tempoLegal,
+  tune2 as tune,
+  tuneById2 as tuneById,
+  tuneRelation2 as tuneRelation
+};

package/dist/types/age-types.d.ts

@@ -0,0 +1,31 @@
+export interface AgeInterval {
+    readonly lo: number;
+    readonly hi: number;
+}
+export interface BirthYears {
+    readonly from: number | null;
+    readonly to: number | null;
+}
+export interface AgeLadder {
+    readonly caps: readonly number[];
+    readonly overs: readonly number[];
+    readonly ranges: readonly number[];
+}
+export interface AgeContext {
+    readonly ladder?: AgeLadder;
+    readonly year?: number | null;
+    readonly top?: boolean;
+}
+export type AgeArm = "band" | "yob" | "open" | "empty";
+export type AgeKind = "under" | "over" | "range" | "adult" | "senior" | "yob";
+export type AgeRefusal = "not-a-band" | "backwards-range" | "senior-without-ladder";
+export type AgeSource = "sibling-narrowed" | "printed-band" | "printed-range" | "printed-yob" | "open";
+export type AgeClause = "under-floored-on-rung" | "youngest-absorbs" | "over-ceiling-from-next-over" | "over-ceiling-refused-gap" | "and-over-no-ceiling" | "range-overlapping" | "range-inclusive" | "range-floor-on-rung" | "range-floor-widened" | "range-adult-floor";
+export type AgeRelation = "same" | "contains" | "overlaps" | "disjoint" | "silent";
+export type AgeRelationReason = "equal" | "a-contains-b" | "b-contains-a" | "partial" | "a-older" | "a-younger" | "a-not-a-band" | "b-not-a-band";
+export interface AgeComparison {
+    readonly relation: AgeRelation;
+    readonly reason: AgeRelationReason;
+}
+export type AgeMisuse = "not-exact" | "empty-average" | "average-of-averages" | "average-as-container" | "average-birth-years" | "average-container-no-year" | "average-in-relation";
+export type YoungFloorVerdict = "clear" | "same-school-only" | "too-young";

package/dist/types/age.d.ts

@@ -0,0 +1,84 @@
+import type { AgeArm, AgeClause, AgeComparison, AgeContext, AgeInterval, AgeKind, AgeLadder, AgeMisuse, AgeRefusal, AgeRelation, AgeRelationReason, AgeSource, BirthYears, YoungFloorVerdict } from "./age-types.ts";
+export type { AgeArm, AgeClause, AgeComparison, AgeContext, AgeInterval, AgeKind, AgeLadder, AgeMisuse, AgeRefusal, AgeRelation, AgeRelationReason, AgeSource, BirthYears, YoungFloorVerdict, };
+export declare const YOUNGEST_FLOOR = 0;
+export declare const ADULT_FLOOR = 18;
+export declare const MAJORS_FLOOR_YEARS = 3;
+export declare const UNDER_CAP: Readonly<{
+    readonly plain: 2;
+    readonly exceptional: 4;
+}>;
+export declare const UNDER_CAP_MAX_TOP = 21;
+export declare const YOUNG_FLOOR: Readonly<{
+    readonly hard: 2;
+    readonly soft: 4;
+}>;
+export declare const MIN_MAJOR_AGE = 4;
+export declare const MIN_FEIS_AGE = 3;
+export declare const DANCE_UP_YEARS = 1;
+export declare const ageOnJanuary1: (year: number, born: number) => number;
+export declare const yearsSinceBirth: (year: number, born: number) => number;
+export interface Age {
+    readonly [Symbol.toStringTag]: "Age";
+    toString(): string;
+    readonly arm: AgeArm;
+    readonly kind: AgeKind | null;
+    readonly ag0: string;
+    readonly ag1: string;
+    readonly ag2: string;
+    readonly parts: readonly number[];
+    readonly length: number;
+    readonly refusal: AgeRefusal | null;
+    readonly source: AgeSource;
+    readonly clauses: readonly AgeClause[];
+    readonly ladder: AgeLadder;
+    readonly year: number | null;
+    isEmpty(): boolean;
+    isAge(): boolean;
+    isExact(): boolean;
+    isAndOver(): boolean;
+    isAdult(): boolean;
+    interval(): AgeInterval | null;
+    birthYears(year?: number): BirthYears;
+    floorObserved(): boolean | null;
+    fitsIn(container: Age): boolean;
+    overlaps(other: Age): boolean;
+}
+export declare class AgeMisuseError extends Error {
+    readonly misuse: AgeMisuse;
+    constructor(misuse: AgeMisuse, detail: string);
+}
+declare function fromPrint(print: string, context?: AgeContext): Age;
+declare function fromYOB(from: number | null, to?: number | null): Age;
+export declare const Age: Readonly<{
+    from: typeof fromPrint;
+    fromYOB: typeof fromYOB;
+}>;
+export declare function birthYearsOfInterval(iv: AgeInterval | null, year: number): BirthYears;
+export declare function ageRelation(a: Age, b: Age): AgeComparison;
+export declare function canOverlap(...ages: readonly Age[]): boolean;
+export declare const AVERAGE_AGE_DECIMALS = 2;
+export declare function roundedMeanHundredths(k: number, n: number): number;
+export interface AverageAge {
+    readonly [Symbol.toStringTag]: "AverageAge";
+    readonly provenance: string;
+    readonly members: readonly Age[];
+    readonly n: number;
+    readonly birthYearSum: number;
+    readonly meanBirthYear: number;
+    toString(): string;
+    isExact(): false;
+    meanAgeHundredths(year: number): number;
+    meanAge(year: number): number;
+    fitsIn(container: Age): boolean;
+    birthYears(): never;
+}
+export declare function isAveraged(a: Age | AverageAge): a is AverageAge;
+export declare function averageAge(ages: readonly Age[]): AverageAge;
+export declare function birthYearsDisjoint(a: BirthYears, b: BirthYears): boolean;
+export declare function birthYearsMeet(card: BirthYears, other: BirthYears, slack?: number): boolean;
+export declare function underCapApplies(bandFrom: number | null, year: number): boolean;
+export declare function underCappedYears(b: BirthYears, year: number, n?: number): BirthYears;
+export declare function underCapRefuses(bandFrom: number, identityFrom: number, n: number): boolean;
+export declare function youngFloor(year: number, oldest: number): YoungFloorVerdict;
+export declare const tooYoungForMajor: (year: number, oldest: number) => boolean;
+export declare const tooYoungForFeis: (year: number, oldest: number) => boolean;

package/dist/types/ceili.d.ts

@@ -0,0 +1,53 @@
+import { type DanceMatch, type DanceRelation } from "./dance-match.ts";
+export type CeiliFamily = "eight-hand" | "four-hand" | "handbook";
+export type CeiliFormation = "set" | "long" | "round";
+export interface CeiliNode {
+    readonly id: string;
+    readonly name: string;
+    readonly irish: string | null;
+    readonly prints: readonly string[];
+    readonly irishPrints: readonly string[];
+    readonly formation: CeiliFormation;
+    readonly hands: number | null;
+    readonly setHands: number | null;
+    readonly family: CeiliFamily;
+}
+export declare const CEILI_NODES: readonly CeiliNode[];
+export interface Ceili {
+    readonly [Symbol.toStringTag]: "Ceili";
+    readonly id: string;
+    readonly name: string;
+    readonly irish: string | null;
+    readonly node: CeiliNode;
+    toString(): string;
+    hands(): number | "long" | "round";
+    setHands(): number | null;
+    isLong(): boolean;
+    family(): CeiliFamily;
+    inHandbook(): boolean;
+}
+export declare function allCeilis(): readonly Ceili[];
+export declare function ceiliById(id: string): Ceili | undefined;
+export interface CeiliContext {
+    readonly list?: "eight-hand" | "four-hand";
+    readonly hands?: number;
+}
+export type CeiliRefusal = "empty" | "dance-type" | "unmatched";
+export interface CeiliReading {
+    readonly [Symbol.toStringTag]: "CeiliReading";
+    readonly print: string;
+    readonly folded: string;
+    readonly candidates: readonly Ceili[];
+    readonly score: number;
+    readonly match: DanceMatch | null;
+    readonly refusal: CeiliRefusal | null;
+    readonly misses: readonly string[];
+    readonly ceili: Ceili | undefined;
+    isCeili(): boolean;
+    isSingular(): boolean;
+    isAmbiguous(): boolean;
+    refine(ctx: CeiliContext): CeiliReading;
+    toString(): string;
+}
+export declare function ceili(print: string, ctx?: CeiliContext): CeiliReading;
+export declare function ceiliRelation(a: CeiliReading, b: CeiliReading): DanceRelation;

package/dist/types/clrg-regions.d.ts

@@ -0,0 +1,31 @@
+export declare const REGIONS: {
+    readonly SRO: "Southern Region USA";
+    readonly WUSRO: "Western Region USA";
+    readonly NERO: "New England Region USA";
+    readonly MARO: "Mid-Atlantic Region USA";
+    readonly MAO: "Mid-America Region USA";
+    readonly WCRO: "Western Canada";
+    readonly ECRO: "Eastern Canada";
+    readonly ULSTER: "Cúige Uladh / Ulster";
+    readonly MUNSTER: "Cúige Mumhan / Munster";
+    readonly LEINSTER: "Cúige Laighean / Leinster";
+    readonly CONNACHT: "Cúige Chonnacht / Connacht";
+    readonly SCOTLAND: "Albain / Scotland";
+    readonly ENG_MIDLANDS: "England — Midlands";
+    readonly ENG_NW: "England — North-West";
+    readonly ENG_NE: "England — North-East";
+    readonly ENG_SOUTH: "England — South (SERC)";
+    readonly RCCEA: "Continental Europe & Asia (RCCEA)";
+    readonly NZ: "New Zealand";
+    readonly AUSTRALIA: "Australia";
+    readonly SOUTH_AFRICA: "South Africa";
+    readonly SOUTH_AMERICA: "South America";
+};
+export type RegionCode = keyof typeof REGIONS;
+export declare const AMBIGUOUS_REGION: ReadonlySet<string>;
+export declare const regionOf: (location: string) => RegionCode | undefined;
+export declare const regionOfPlace: (location: string) => RegionCode | undefined;
+export declare const isStateCode: (token: string) => boolean;
+export declare function isPlaceName(phrase: string): boolean;
+export declare const AMBIGUOUS_PLACES: ReadonlySet<string>;
+export declare function resolvePhrase(phrase: string): RegionCode[];

package/dist/types/dance-match.d.ts

@@ -0,0 +1,28 @@
+export type DanceMatch = "exact" | "within" | "around" | "fuzzy";
+export declare const FUZZY_FLOOR = 0.75;
+export declare const WITHIN_SCORE = 0.9;
+export declare const AROUND_SCORE = 0.85;
+export declare function foldDancePrint(print: string): string;
+export declare function splitTempo(print: string, range?: {
+    readonly min: number;
+    readonly max: number;
+}): {
+    rest: string;
+    bpm: number | null;
+};
+export declare function matchFolded(q: string, c: string): {
+    kind: DanceMatch;
+    score: number;
+} | null;
+export declare function scoreFolded(q: string, c: string): number;
+export interface Matchable {
+    readonly id: string;
+    readonly aliases: readonly string[];
+}
+export declare function matchNodes<T extends Matchable>(folded: string, nodes: readonly T[]): {
+    nodes: T[];
+    score: number;
+    kind: DanceMatch | null;
+};
+export type DanceRelation = "same" | "overlaps" | "conflict" | "silent";
+export declare function candidateRelation(a: readonly string[], b: readonly string[]): DanceRelation;

package/dist/types/dance-types.d.ts

@@ -0,0 +1,9 @@
+export type { DanceMatch, DanceRelation } from "./dance-match.ts";
+export type DanceType = "reel" | "light-jig" | "single-jig" | "slip-jig" | "treble-jig" | "hornpipe" | "traditional-set" | "set-dance";
+export declare const DANCE_TYPES: readonly DanceType[];
+export type TimeSignature = "2/4" | "4/4" | "6/8" | "9/8" | "6/8+9/8";
+export type SetRhythm = "jig" | "hornpipe";
+export declare function rhythmOfTime(time: TimeSignature): SetRhythm;
+export declare function danceTypes(print: string): readonly DanceType[];
+export declare function danceTypePrints(): ReadonlyMap<string, readonly DanceType[]>;
+export declare function isDanceTypePrint(print: string): boolean;

package/dist/types/dance.d.ts

@@ -0,0 +1,14 @@
+import { type Ceili, type CeiliReading } from "./ceili.ts";
+import { type Tune, type TuneReading } from "./tune.ts";
+export type DanceRound = "set" | "traditional-set" | "ceili" | "eight-hand" | "four-hand";
+export interface DanceReading {
+    readonly print: string;
+    readonly tunes: TuneReading;
+    readonly ceilis: CeiliReading;
+    readonly misses: readonly string[];
+    readonly candidates: readonly (Tune | Ceili)[];
+    roundHeld(): boolean;
+    isAmbiguousKind(): boolean;
+    isSingular(): boolean;
+}
+export declare function dance(print: string, round?: DanceRound): DanceReading;

package/dist/types/noun-index.d.ts

@@ -0,0 +1,67 @@
+import { type PersonName, type ResolvedNameOrder, type TransitiveLevel } from "@finbheara/names/normalize";
+export type SqlValue = string | number | bigint | null;
+export interface SqlStatement {
+    run(...params: SqlValue[]): unknown;
+    all(...params: SqlValue[]): unknown[];
+}
+export interface SqlHandle {
+    prepare(sql: string): SqlStatement;
+}
+export type EncodedRow = Readonly<Record<string, string | null>>;
+export interface NounEncoder<X, L extends string = string> {
+    readonly columns: readonly string[];
+    readonly levels: readonly L[];
+    readonly indexed: readonly string[];
+    encode(x: X): EncodedRow;
+    key?(x: X, level: L): string | null;
+    decode(row: EncodedRow): X;
+}
+export interface IndexOptions {
+    readonly table?: string;
+    readonly value?: string;
+    readonly valueType?: string;
+}
+export interface IndexRow<V> {
+    readonly value: V;
+    readonly row: EncodedRow;
+}
+export interface IndexMap<X, V, L extends string> {
+    readonly dop: L;
+    readonly size: number;
+    get(x: X): V | undefined;
+    has(x: X): boolean;
+    set(x: X, value: V): this;
+    delete(x: X): boolean;
+    clear(): void;
+    keys(): IterableIterator<X>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[X, V]>;
+    [Symbol.iterator](): IterableIterator<[X, V]>;
+}
+export interface NounIndex<X, L extends string, V extends SqlValue> {
+    readonly table: string;
+    readonly encoder: NounEncoder<X, L>;
+    add(x: X, value: V): void;
+    addAll(entries: Iterable<readonly [X, V]>): void;
+    get(x: X, level: L): V[];
+    has(x: X, level: L): boolean;
+    find(column: string, key: string): V[];
+    rows(where: Readonly<Record<string, readonly string[]>>, columns?: readonly string[]): IndexRow<V>[];
+    glob(column: string, pattern: string, columns?: readonly string[]): IndexRow<V>[];
+    nouns(value: V): X[];
+    remove(value: V): number;
+    size(): number;
+    map(level: L): IndexMap<X, V, L>;
+}
+export declare function indexSchema(encoder: NounEncoder<unknown>, options?: IndexOptions): {
+    table: string;
+    indexes: string[];
+};
+export declare function createIndex<X, L extends string, V extends SqlValue = SqlValue>(handle: SqlHandle, encoder: NounEncoder<X, L>, options?: IndexOptions): NounIndex<X, L, V>;
+export type PersonReader = (print: string, order: ResolvedNameOrder) => PersonName;
+export interface PersonEncoderOptions {
+    readonly read?: PersonReader;
+    readonly print?: string;
+    readonly reading?: string;
+}
+export declare function personEncoder(options?: PersonEncoderOptions): NounEncoder<PersonName, TransitiveLevel>;

package/dist/types/place-tree.d.ts

@@ -0,0 +1,4 @@
+import type { PlaceNode } from "./place-types.ts";
+export declare const AMBIGUOUS_PRINTS: readonly string[];
+export declare const CROSS_BORDER_REGIONS: readonly string[];
+export declare const PLACE_NODES: readonly PlaceNode[];

package/dist/types/place-types.d.ts

@@ -0,0 +1,24 @@
+export type PlaceKind = "world" | "continent" | "country" | "subdivision" | "city" | "body" | "region";
+export interface PlaceNode {
+    readonly id: string;
+    readonly kind: PlaceKind;
+    readonly name: string;
+    readonly geo: string | null;
+    readonly admin: string | null;
+    readonly prints: readonly string[];
+    readonly codes: readonly string[];
+    readonly truncations?: readonly string[];
+    readonly iso2?: string;
+    readonly iso3?: string;
+    readonly isoNumeric?: string;
+    readonly oireachtas?: string;
+}
+export type PlaceMatch = "id" | "code" | "print" | "phrase" | "iso" | "county" | "truncation";
+export type PlaceRefusal = "school" | "organization" | "placeholder" | "damaged";
+export type PlaceRelation = "same" | "contains" | "overlaps" | "conflict" | "silent";
+export interface PlaceContext {
+    readonly region?: string;
+    readonly country?: string;
+    readonly near?: string;
+    readonly declared?: boolean;
+}

package/dist/types/place.d.ts

@@ -0,0 +1,98 @@
+import type { PlaceContext, PlaceKind, PlaceMatch, PlaceNode, PlaceRefusal, PlaceRelation } from "./place-types.ts";
+export type { PlaceContext, PlaceKind, PlaceMatch, PlaceNode, PlaceRefusal, PlaceRelation };
+export type PlaceArm = "resolved" | "plural" | "ambiguous" | "unread";
+export interface AbstractPlace {
+    readonly [Symbol.toStringTag]: "Place";
+    toString(): string;
+    readonly arm: PlaceArm;
+    readonly pl0: string;
+    readonly pl1: string;
+    readonly pl2: string;
+    readonly pl3: string;
+    readonly nodes: readonly PlaceNode[];
+    readonly parts: readonly PlaceNode[];
+    readonly ambiguous: boolean;
+    readonly level: PlaceKind | null;
+    readonly match: PlaceMatch | null;
+    readonly truncated: boolean;
+    readonly refusal: PlaceRefusal | null;
+    readonly misses: readonly string[];
+    readonly length: number;
+    isEmpty(): boolean;
+    isPlace(): boolean;
+    isSingular(): this is ResolvedPlace;
+    isPlural(): this is PluralPlaces;
+    isAmbiguous(): boolean;
+    refine(ctx: string | PlaceContext): Place;
+    contains(x: string): boolean;
+    overlaps(x: string): boolean;
+    readonly country: string | undefined;
+    readonly body: string | undefined;
+    readonly region: string | undefined;
+}
+export interface ResolvedPlace extends AbstractPlace {
+    readonly arm: "resolved";
+    readonly administrativeAreaLevel1: string | undefined;
+    readonly admin1: string | undefined;
+    readonly administrativeAreaLevel2: string | undefined;
+    readonly admin2: string | undefined;
+    readonly locality: string | undefined;
+    readonly types: readonly string[];
+}
+export interface PluralPlaces extends AbstractPlace {
+    readonly arm: "plural";
+    readonly members: readonly ResolvedPlace[];
+}
+export interface AmbiguousPlace extends AbstractPlace {
+    readonly arm: "ambiguous";
+    readonly candidates: readonly ResolvedPlace[];
+}
+export interface UnreadPlace extends AbstractPlace {
+    readonly arm: "unread";
+}
+export type Place = ResolvedPlace | PluralPlaces | AmbiguousPlace | UnreadPlace;
+export type PlaceRefusals = (print: string) => PlaceRefusal | undefined;
+export interface PlaceReaderOptions {
+    readonly tree?: readonly PlaceNode[];
+    readonly refusals?: PlaceRefusals | ReadonlyMap<string, PlaceRefusal>;
+    readonly capacity?: number;
+}
+export declare const DEFAULT_PLACE_CAPACITY = 8192;
+export declare function createPlaceReader(options?: PlaceReaderOptions): {
+    place: (print: string, ctx?: string | PlaceContext) => Place;
+    isPlaceToken: (token: string, cut?: boolean, declared?: boolean) => boolean;
+    countryCodeOf: (token: string) => string | undefined;
+    areAllPlaceTokens: (tokens: readonly string[], off?: number, declared?: boolean) => boolean;
+    placeFromId: (id: string) => Place;
+    oireachtasOfRegion: (regionId: string | undefined) => string | undefined;
+    regionOfOireachtas: (code: string) => Place;
+    placeStats: () => {
+        hits: number;
+        misses: number;
+        evictions: number;
+    };
+    resetPlaceCache: (next?: number) => void;
+    placeRelation: (a: Place, b: Place) => PlaceRelation;
+    placesRelation: (a: readonly Place[], b: readonly Place[]) => PlaceRelation;
+    probablySamePlace: (a: Place, b: Place) => boolean;
+    sameReading: (a: Place, b: Place) => boolean;
+};
+export type PlaceReader = ReturnType<typeof createPlaceReader>;
+export declare const DEFAULT_PLACE_READER: PlaceReader;
+export declare function place(print: string, ctx?: string | PlaceContext): Place;
+export declare function isPlaceToken(token: string, cut?: boolean, declared?: boolean): boolean;
+export declare function countryCodeOf(token: string): string | undefined;
+export declare function areAllPlaceTokens(tokens: readonly string[], off?: number, declared?: boolean): boolean;
+export declare function placeFromId(id: string): Place;
+export declare function oireachtasOfRegion(regionId: string | undefined): string | undefined;
+export declare function regionOfOireachtas(code: string): Place;
+export declare function placeStats(): {
+    hits: number;
+    misses: number;
+    evictions: number;
+};
+export declare function resetPlaceCache(next?: number): void;
+export declare function placeRelation(a: Place, b: Place): PlaceRelation;
+export declare function placesRelation(a: readonly Place[], b: readonly Place[]): PlaceRelation;
+export declare function probablySamePlace(a: Place, b: Place): boolean;
+export declare function sameReading(a: Place, b: Place): boolean;

package/dist/types/school-compare.d.ts

@@ -0,0 +1,39 @@
+import { type SchoolName } from "./school-name.ts";
+export type SchoolDop = "sn0" | "sn1" | "sn2" | "sn3" | "sn4" | "realWords" | "surnames";
+export declare function schoolTokensAt(name: SchoolName, dop: SchoolDop): readonly string[];
+export declare function probablySameSchool(a: SchoolName, b: SchoolName, dop: SchoolDop): boolean;
+export declare function differOnlyByDamagedGenerics(a: SchoolName, b: SchoolName): boolean;
+export declare function isColumnCutOf(a: SchoolName, b: SchoolName): boolean;
+export declare function isInitialismOf(a: SchoolName, b: SchoolName, which: "declared" | "derived"): boolean;
+export declare function sameInEveryPart(a: SchoolName, b: SchoolName): boolean;
+export declare function schoolCompare(a: SchoolName, b: SchoolName, dop: SchoolDop): -1 | 0 | 1;
+export interface SchoolSet {
+    readonly dop: SchoolDop;
+    readonly size: number;
+    get(name: SchoolName): SchoolName | undefined;
+    has(name: SchoolName): boolean;
+    add(name: SchoolName): this;
+    delete(name: SchoolName): boolean;
+    clear(): void;
+    values(): IterableIterator<SchoolName>;
+    [Symbol.iterator](): IterableIterator<SchoolName>;
+}
+export interface SchoolMap<V> {
+    readonly dop: SchoolDop;
+    readonly size: number;
+    get(name: SchoolName): V | undefined;
+    has(name: SchoolName): boolean;
+    set(name: SchoolName, value: V): this;
+    delete(name: SchoolName): boolean;
+    clear(): void;
+    keys(): IterableIterator<SchoolName>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[SchoolName, V]>;
+    [Symbol.iterator](): IterableIterator<[SchoolName, V]>;
+}
+export declare function setOfSchools(dop: SchoolDop): SchoolSet;
+export declare function mapOfSchools<V>(dop: SchoolDop, entries?: Iterable<readonly [SchoolName, V]>): SchoolMap<V>;
+export declare const SCHOOL_LEVEL_COLUMNS: readonly ["sn0", "sn1", "sn2", "sn3", "sn4", "realWords"];
+export type SchoolLevelColumn = (typeof SCHOOL_LEVEL_COLUMNS)[number];
+export declare function schoolColumns(name: SchoolName): Readonly<Record<SchoolLevelColumn, string | null>>;
+export declare function isLadderLevel(dop: SchoolDop): boolean;

package/dist/types/school-encoder.d.ts

@@ -0,0 +1,8 @@
+import type { NounEncoder } from "./noun-index.ts";
+import { type SchoolLevelColumn } from "./school-compare.ts";
+import { type SchoolName, type SchoolNameParser } from "./school-name.ts";
+export interface SchoolEncoderOptions {
+    readonly reader?: SchoolNameParser;
+    readonly print?: string;
+}
+export declare function schoolEncoder(options?: SchoolEncoderOptions): NounEncoder<SchoolName, SchoolLevelColumn>;

package/dist/types/school-exception-vocabulary.d.ts

@@ -0,0 +1,23 @@
+import type { SchoolTokenClass } from "./school-tokens.ts";
+export interface SchoolNameException {
+    phrase: string;
+    scope: "label" | "phrase";
+    as: SchoolTokenClass;
+    token: string;
+}
+export declare const SCHOOL_NAME_EXCEPTIONS: readonly SchoolNameException[];
+export declare const EXCEPTIONS_BY_LENGTH: readonly SchoolNameException[];
+export type RefusalReason = "organization" | "placeholder" | "damaged" | "not-a-name";
+export declare const REFUSAL_REASONS: readonly ["organization", "placeholder", "damaged", "not-a-name"];
+type AssertTrue<T extends true> = T;
+export type EveryDeclaredReasonIsARefusalReason = AssertTrue<(typeof REFUSAL_REASONS)[number] extends RefusalReason ? true : false>;
+export type EveryRefusalReasonIsDeclared = AssertTrue<RefusalReason extends (typeof REFUSAL_REASONS)[number] ? true : false>;
+export interface NotASchool {
+    pattern: string;
+    kind: "exact" | "prefix" | "regex";
+    reason: RefusalReason;
+}
+export declare const NOT_A_SCHOOL: readonly NotASchool[];
+export declare function notASchoolIn(rows: readonly NotASchool[]): (print: string) => NotASchool | undefined;
+export declare function exceptionsByLength(rows: readonly SchoolNameException[]): readonly SchoolNameException[];
+export {};

package/dist/types/school-fluff-vocabulary.d.ts

@@ -0,0 +1,16 @@
+export type SchoolFluffKind = "word" | "phrase";
+export interface SchoolFluff {
+    canonical: string;
+    kind: SchoolFluffKind;
+    lowerInside: boolean;
+    descriptor: boolean;
+    truncatable: boolean;
+    tokenFluff: boolean;
+}
+export declare const SCHOOL_FLUFF_VOCABULARY: ReadonlyMap<string, SchoolFluff>;
+export declare function schoolFluff(text: string): SchoolFluff | undefined;
+export declare function isFluffWord(token: string): boolean;
+export declare function isTruncatedFluff(token: string): boolean;
+export declare const FLUFF_PHRASES: readonly string[];
+export declare function isFluffPhrasePrefix(text: string): boolean;
+export declare function trailingFluffRun(tokens: readonly string[], distinctive: (token: string) => boolean): number;

package/dist/types/school-fused-prefix.d.ts

@@ -0,0 +1 @@
+export declare function joinedPrefix(printed: string, next: string): string | undefined;

package/dist/types/school-identity.d.ts

@@ -0,0 +1,9 @@
+import { type SchoolName, type SchoolNameParser } from "./school-name.ts";
+export type IdentityVerdict = "CANDIDATE" | "BLOCKED" | "AMBIGUOUS" | "DIFFERENT";
+export interface IdentityResult {
+    verdict: IdentityVerdict;
+    reason: "name-parts-differ" | "no-name-part" | "no-school" | "institution-type-conflict" | "location-conflict" | "unqualified-vs-qualified" | "same-name-and-type" | "damaged-generic-word" | "truncated-print" | "declared-initialism" | "derived-initialism" | "promoted-token-identity" | "context-place-conflict";
+    sharesNameParts: boolean;
+}
+export declare function compareSchoolNames(a: string, b: string, reader: SchoolNameParser): IdentityResult;
+export declare function compareSchools(a: SchoolName, b: SchoolName): IdentityResult;

package/dist/types/school-institution-vocabulary.d.ts

@@ -0,0 +1,20 @@
+export type InstitutionType = "academy" | "school" | "scoilrince" | "institute" | "company" | "studio" | "center" | "club";
+export type InstitutionPosition = "prefix" | "suffix";
+export type InstitutionKind = "word" | "phrase";
+export interface SchoolInstitution {
+    canonical: InstitutionType;
+    label: string;
+    kind: InstitutionKind;
+    position: InstitutionPosition;
+    truncatable: boolean;
+    glued: boolean;
+}
+export declare const SCHOOL_INSTITUTION_VOCABULARY: ReadonlyMap<string, SchoolInstitution>;
+export declare function schoolInstitution(text: string): SchoolInstitution | undefined;
+export declare function isInstitutionWord(text: string): boolean;
+export declare function institutionCanonical(text: string): InstitutionType | undefined;
+export declare function institutionLabel(type: InstitutionType): string;
+export declare const INSTITUTION_TYPES: readonly InstitutionType[];
+export declare const INSTITUTION_PHRASES: readonly string[];
+export declare const GLUED_INSTITUTION_SUFFIXES: readonly string[];
+export declare function truncatedInstitution(tail: string): SchoolInstitution | undefined;

package/dist/types/school-location.d.ts

@@ -0,0 +1,16 @@
+export declare const NEVER_PLACE: ReadonlyMap<string, string>;
+export declare const NEVER_NAME: ReadonlyMap<string, string>;
+export interface PrintZones {
+    qualifier: ReadonlySet<string>;
+    bracketed: ReadonlySet<string>;
+    qualifierAny: ReadonlySet<string>;
+    web: readonly (readonly [number, number])[];
+    webOnly: ReadonlySet<string>;
+    tailCode: {
+        readonly folded: string;
+        readonly at: number;
+        readonly only: boolean;
+    } | null;
+}
+export declare function printZones(raw: string): PrintZones;
+export declare function opensLocation(folded: string, at: PrintZones, index?: number): boolean;

package/dist/types/school-match-key.d.ts

@@ -0,0 +1,5 @@
+export declare const SCHOOL_FLUFF_WORDS: ReadonlySet<string>;
+export declare const SCHOOL_GENERIC_NAME_PARTS: ReadonlySet<string>;
+export declare function hasSpecificToken(tokens: Iterable<string>): boolean;
+export declare function foldSchoolName(raw: string): string;
+export declare function schoolKeyTokens(raw: string): string[];