@finbheara/names 0.16.0 → 0.18.0

package/dist/chunks/index-qmn87bdh.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/normalize/given-diminutives.ts", "../src/normalize/given-families.ts"],
+  "sourcesContent": [
+    "/**\n * given-diminutives.ts — ONE GIVEN-NAME DIMINUTIVE TABLE, read by the TypeScript side.\n *\n * `./given-diminutives.json` is the table and this file is its reader. A consumer in another\n * language reads the table as `names tables given-name` prints it (`../cli/tables.ts`), never\n * this file, so the file's layout may change and no second copy exists. An earlier\n * adjudicator carried a `FAMILIAR` map of eight entries and said *\"the name primitives are\n * where it belongs once a second consumer wants one\"*; the teachers-directory gate is that\n * second consumer, and the eight entries are in the table.\n *\n * A RELATION OF A PAIR AND NEVER A KEY. Nothing here rewrites a given name: a stored key,\n * a filing key and every rendering keep the print's own spelling. A caller asks whether\n * TWO given names are one family, at the moment it compares them, and nowhere else, so the\n * root never leaves this module: `sameGivenFamily` and `givenFamilyTable` answer about a\n * pair and neither returns a root, for that reason.\n *\n * SPELLINGS, FAMILIES AND THE GATE. Two different given names are related in one of three\n * ways, and the answer says which:\n *\n *   - `given-variant`: two spellings of one name (`Connor` / `Conor`, `Sara` / `Sarah`). A\n *     spelling is not a familiar form, so `variants` is its own table, and a gate admits it.\n *   - `given-family`: after each spelling is read as its canonical, the two share a ROOT of\n *     `families` (`Tom` / `Thomas`, `Kate` / `Katherine`), and a gate admits it.\n *   - `given-family-not-gate`: they share a root, but only through a `notAtGate` form: a name in\n *     its own right (`Megan`, `Grace`), a translation (`Sean`, `Padraig`), another gender's\n *     name (`Michelle`, `Sam`) or a form of more than one root (`Ellie`, `Evie`). The lane\n *     reads it as evidence below an exact match; a gate refuses it.\n *\n * EVERY ROOT, NEVER THE FIRST. A form under several roots meets each of them (`Evie` is\n * Evelyn's, Genevieve's, Eve's and Eva's), and every such form is `notAtGate`, because the\n * form alone cannot say which root its bearer carries. Sharing a root is not transitive:\n * `Eve` and `Eva` share none, though `Evie` meets both. A `notAtGate` form is refused AS A\n * FORM: where it is the root itself (`Caitlin` / `Cait`), its own forms meet it at a gate.\n */\n\nimport table from \"./given-diminutives.json\";\n\ninterface Table {\n\tvariants: Record<string, readonly string[]>;\n\tfamilies: Record<string, readonly string[]>;\n\tnotAtGate: readonly string[];\n}\n\nconst TABLE = table as unknown as Table;\n\n/**\n * The table as this module reads it, for `names tables given-name`, which prints it. Not a\n * package export: the printed form is the contract, and this file's layout may change.\n */\nexport function givenDiminutiveTable(): {\n\treadonly variants: Readonly<Record<string, readonly string[]>>;\n\treadonly families: Readonly<Record<string, readonly string[]>>;\n\treadonly notAtGate: readonly string[];\n} {\n\treturn TABLE;\n}\n\n/** spelling -> its canonical spelling; a canonical maps to itself only by absence. */\nconst CANONICAL: ReadonlyMap<string, string> = (() => {\n\tconst out = new Map<string, string>();\n\tfor (const [canonical, spellings] of Object.entries(TABLE.variants))\n\t\tfor (const s of spellings) out.set(s, canonical);\n\treturn out;\n})();\n\n/** canonical name -> every root it belongs to: itself when it is a root, and each root it is a form of. */\nconst ROOTS: ReadonlyMap<string, ReadonlySet<string>> = (() => {\n\tconst out = new Map<string, Set<string>>();\n\tconst add = (form: string, root: string) => {\n\t\tlet roots = out.get(form);\n\t\tif (roots === undefined) out.set(form, (roots = new Set()));\n\t\troots.add(root);\n\t};\n\tfor (const [root, forms] of Object.entries(TABLE.families)) {\n\t\tadd(root, root);\n\t\tfor (const f of forms) add(f, root);\n\t}\n\treturn out;\n})();\n\nconst NOT_AT_GATE: ReadonlySet<string> = new Set(TABLE.notAtGate);\n\nconst canonical = (name: string): string => CANONICAL.get(name) ?? name;\n\n/** May `name` (canonical) meet the other side of a pair through `root` at a gate? */\nconst gateThrough = (name: string, root: string): boolean =>\n\tname === root || !NOT_AT_GATE.has(name);\n\n/**\n * Do two DIFFERENT given names (NN3, letters only) stand for one another at a gate?\n *\n * True exactly when `givenFamilyTable` relates them by a gate-safe answer: two spellings of\n * one name, or one family through no `notAtGate` form. Two equal names answer `false`:\n * equality is the caller's own test and this is the tolerance past it, so a caller can tell\n * which one admitted a pair.\n */\nexport function sameGivenFamily(a: string, b: string): boolean {\n\tconst via = givenFamilyTable(a, b);\n\treturn via === \"given-variant\" || via === \"given-family\";\n}\n\n/**\n * What the table says about two DIFFERENT given names (NN3, letters only), as a kinship\n * `via`: `given-variant` for two spellings of one name, `given-family` where the two share a\n * root and a gate admits the pair, `given-family-not-gate` where every root they share is\n * reached through a `notAtGate` form, and `null` where the table does not relate them. Two\n * equal names answer `null`, for `sameGivenFamily`'s reason.\n *\n * THE DEFAULT GIVEN-NAME PROVIDER of `createNameKinship` (`./name-kinship.ts`).\n * `sameGivenFamily` is defined as its gate-safe answers, so the gate and the tolerant relation\n * cannot disagree about a pair.\n */\nexport function givenFamilyTable(\n\ta: string,\n\tb: string,\n): \"given-variant\" | \"given-family\" | \"given-family-not-gate\" | null {\n\tif (a === b) return null;\n\tconst ca = canonical(a);\n\tconst cb = canonical(b);\n\tif (ca === cb) return \"given-variant\";\n\tconst ra = ROOTS.get(ca);\n\tconst rb = ROOTS.get(cb);\n\tif (ra === undefined || rb === undefined) return null;\n\tlet shared = false;\n\tfor (const root of ra) {\n\t\tif (!rb.has(root)) continue;\n\t\tif (gateThrough(ca, root) && gateThrough(cb, root)) return \"given-family\";\n\t\tshared = true;\n\t}\n\treturn shared ? \"given-family-not-gate\" : null;\n}\n",
+    "/**\n * given-families.ts — THE EXTENDED GIVEN-NAME FAMILY LIST, read by the TypeScript side.\n *\n * `./given-families.json` is the list and this file is its reader; `scripts/given-families.ts`\n * builds the list and `./given-families.MANIFEST.json` records its sources.\n *\n * TWO TIERS OF GIVEN-NAME KNOWLEDGE. `./given-diminutives.json` is the GATE tier: pairs this\n * package is sure of, curated by hand, some of them admitted at an identity gate. This list\n * is the EXTENDED tier: every family the sources record for English, Irish, Scottish, Welsh,\n * French, Italian, Spanish, German, Dutch and Polish usage, about 2,600 names. A pair it\n * relates MAY be one name, and the answer is `given-maybe`, which no gate admits.\n *\n * AN EXACT LIST, NOT A FILTER. A bloom filter of the same pairs at 8 KB answers about fifty\n * false partners for every given name it is asked about; the exact list is a few KB more\n * and answers none.\n *\n * A FAMILY IS CLOSED. Two names relate when they are a root and its form, or two forms of\n * one root (`Kate` / `Katie`, both Catherine's). A form under several roots meets each\n * root's family, and nothing is transitive across families: `Kit` meets Catherine's and\n * Christopher's, and `Kate` / `Chris` stay apart.\n *\n * A TIER BOUNDS HOW RARE A FORM MAY BE. Each form carries 1 (common), 2 (uncommon) or 3\n * (rare); a pair's tier is its rarer member's, the root counting as 1, and where two names\n * share several families the commonest counts. `maxTier` admits pairs up to that tier.\n */\n\nimport list from \"./given-families.json\";\n\n/** How common a form is: 1 common, 2 uncommon, 3 rare. */\nexport type GivenFamilyTier = 1 | 2 | 3;\n\nexport interface GivenFamilyListOptions {\n\t/** The rarest tier admitted. Default 3: every pair the list holds. */\n\treadonly maxTier?: GivenFamilyTier;\n\t/**\n\t * The families, one `ROOT,FORM:TIER,…` line each, NN3 upper case. Default: the shipped\n\t * `given-families.json`. A caller with its own list passes it here.\n\t */\n\treadonly families?: readonly string[];\n}\n\n/** A given-name provider over the extended list: `given-maybe` or `null`. */\nexport type GivenFamilyList = (a: string, b: string) => \"given-maybe\" | null;\n\n/** name -> root -> the name's tier in that root's family (a root's own is 1) */\ntype Memberships = ReadonlyMap<string, ReadonlyMap<string, number>>;\n\n/**\n * The lines, read. A malformed line throws: the list is data this package ships or a caller\n * supplies, and a line read wrong would relate names silently.\n */\nfunction parseFamilies(lines: readonly string[]): Memberships {\n\tconst out = new Map<string, Map<string, number>>();\n\tconst join = (name: string, root: string, tier: number) => {\n\t\tlet roots = out.get(name);\n\t\tif (roots === undefined) out.set(name, (roots = new Map()));\n\t\troots.set(root, Math.min(roots.get(root) ?? tier, tier));\n\t};\n\tfor (const line of lines) {\n\t\tconst [root, ...forms] = line.split(\",\");\n\t\tif (root === undefined || !/^[A-Z]+$/.test(root))\n\t\t\tthrow new Error(`given-families: bad root in \"${line}\"`);\n\t\tjoin(root, root, 1);\n\t\tfor (const entry of forms) {\n\t\t\tconst m = /^([A-Z]+):([123])$/.exec(entry);\n\t\t\tif (m === null) throw new Error(`given-families: bad form \"${entry}\" in \"${line}\"`);\n\t\t\tjoin(m[1] as string, root, Number(m[2]));\n\t\t}\n\t}\n\treturn out;\n}\n\n/**\n * The extended list as a `GivenProvider` for `createNameKinship`: `given-maybe` where two\n * DIFFERENT names (NN3) share a family within `maxTier`, `null` otherwise. Two equal names\n * answer `null`, as `givenFamilyTable`'s do.\n *\n * The list is parsed on the first question, once per provider.\n */\nexport function createGivenFamilyList(options: GivenFamilyListOptions = {}): GivenFamilyList {\n\tconst maxTier = options.maxTier ?? 3;\n\tconst lines = options.families ?? (list as { families: readonly string[] }).families;\n\tlet members: Memberships | undefined;\n\treturn (a, b) => {\n\t\tif (a === b) return null;\n\t\tmembers ??= parseFamilies(lines);\n\t\tconst ra = members.get(a);\n\t\tconst rb = members.get(b);\n\t\tif (ra === undefined || rb === undefined) return null;\n\t\tfor (const [root, ta] of ra) {\n\t\t\tconst tb = rb.get(root);\n\t\t\tif (tb !== undefined && Math.max(ta, tb) <= maxTier) return \"given-maybe\";\n\t\t}\n\t\treturn null;\n\t};\n}\n\n/**\n * The shipped list as root -> form -> tier, roots and forms sorted, for `names tables\n * given-name`, which prints it. Not a package export: the printed form is the contract.\n */\nexport function givenFamilyTiers(): Record<string, Record<string, GivenFamilyTier>> {\n\tconst byRoot = new Map<string, Map<string, GivenFamilyTier>>();\n\tfor (const [name, roots] of parseFamilies((list as { families: readonly string[] }).families))\n\t\tfor (const [root, tier] of roots) {\n\t\t\tif (name === root) continue;\n\t\t\tlet forms = byRoot.get(root);\n\t\t\tif (forms === undefined) byRoot.set(root, (forms = new Map()));\n\t\t\tforms.set(name, tier as GivenFamilyTier);\n\t\t}\n\tconst out: Record<string, Record<string, GivenFamilyTier>> = {};\n\tfor (const root of [...byRoot.keys()].sort())\n\t\tout[root] = Object.fromEntries([...byRoot.get(root)!].sort(([a], [b]) => (a < b ? -1 : 1)));\n\treturn out;\n}\n\n/** The shipped list, every tier: the second given-name provider of `nameKinship`. */\nexport const givenFamilyList: GivenFamilyList = createGivenFamilyList();\n"
+  ],
+  "mappings": "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",
+  "debugId": "0A72D6F5743D283A64756E2164756E21",
+  "names": []
+}