@finbheara/names 0.16.0 → 0.17.0

package/dist/chunks/index-n6fpj92s.js

@@ -0,0 +1,1418 @@
+import {
+  isSurname2,
+  isGiven2,
+  isAmbiguous2,
+  Lexicon2
+} from "./index-0wpvbdgh.js";
+import {
+  givenFamilyTable2,
+  givenFamilyList2
+} from "./index-qmn87bdh.js";
+import {
+  isPlaceWordFlags
+} from "./index-tqdbxd92.js";
+import {
+  doubleMetaphone2
+} from "./index-ebebeamh.js";
+import {
+  nameFold2,
+  isPlaceholderPrint2,
+  isNoNamePrint2,
+  isNameSuffix,
+  tokenize,
+  commaReading2,
+  levelOf2,
+  defaultPersonNameFactory2
+} from "./index-tk01chxw.js";
+import {
+  isTeamPrint2
+} from "./index-0phgwy52.js";
+import {
+  isStandaloneNameParticle2
+} from "./index-23rzmwe2.js";
+// src/normalize/name-mojibake.ts
+var CP1252 = new Map([
+  [8364, 128],
+  [8218, 130],
+  [402, 131],
+  [8222, 132],
+  [8230, 133],
+  [8224, 134],
+  [8225, 135],
+  [710, 136],
+  [8240, 137],
+  [352, 138],
+  [8249, 139],
+  [338, 140],
+  [381, 142],
+  [8216, 145],
+  [8217, 146],
+  [8220, 147],
+  [8221, 148],
+  [8226, 149],
+  [8211, 150],
+  [8212, 151],
+  [732, 152],
+  [8482, 153],
+  [353, 154],
+  [8250, 155],
+  [339, 156],
+  [382, 158],
+  [376, 159]
+].map(([c, b]) => [String.fromCharCode(c), b]));
+var UTF8 = new TextDecoder("utf-8", { fatal: true });
+var A0_LEAD = /^[Â-Å]$/u;
+function repairMojibake2(v) {
+  if (!/[Â-ô]/u.test(v))
+    return v;
+  const bytes = [];
+  const cs = [...v];
+  for (let i = 0;i < cs.length; i++) {
+    const c = cs[i];
+    const code = c.codePointAt(0);
+    const mapped = CP1252.get(c);
+    if (mapped !== undefined)
+      bytes.push(mapped);
+    else if (code === 32 && i > 1 && A0_LEAD.test(cs[i - 1]) && /\S/u.test(cs[i - 2])) {
+      bytes.push(160);
+    } else if (code < 256)
+      bytes.push(code);
+    else
+      return v;
+  }
+  try {
+    return UTF8.decode(new Uint8Array(bytes));
+  } catch {
+    return v;
+  }
+}
+// src/normalize/multiset.ts
+function subMultiset(outer, inner) {
+  const left = [...inner];
+  for (const part of outer) {
+    const at = left.indexOf(part);
+    if (at < 0)
+      return false;
+    left.splice(at, 1);
+  }
+  return true;
+}
+
+// src/normalize/name-middle.ts
+function suffixCut(p) {
+  return Math.max(1, p.givenFields().length - p.suffixes.length);
+}
+function middleFields(p) {
+  return p.givenFields().slice(1, suffixCut(p));
+}
+function suffixFields(p) {
+  return p.givenFields().slice(suffixCut(p));
+}
+var sameList = (x, y) => x.length === y.length && x.every((v, i) => v === y[i]);
+var isInitial = (field) => field.length === 1;
+function comparePosition2(x, y) {
+  if (x === y)
+    return null;
+  if (isInitial(x) && isInitial(y))
+    return "initials-differ";
+  if (isInitial(x))
+    return y.startsWith(x) ? null : "initial-differs-from-middle";
+  if (isInitial(y))
+    return x.startsWith(y) ? null : "initial-differs-from-middle";
+  return "middles-differ";
+}
+function nameRelation2(a, b) {
+  if (!a.isPerson() || !b.isPerson())
+    return { relation: "different", reason: "not-a-person" };
+  const ga = a.givenFields();
+  const gb = b.givenFields();
+  if (a.surnameKey() !== b.surnameKey() || ga[0] !== gb[0] || ga[0] === undefined) {
+    return { relation: "different", reason: "head-differs" };
+  }
+  return tailRelation(a, b);
+}
+function tailRelation(a, b) {
+  if (!sameList(suffixFields(a), suffixFields(b))) {
+    return { relation: "different", reason: "suffixes-differ" };
+  }
+  const ma = middleFields(a);
+  const mb = middleFields(b);
+  if (sameList(ma, mb))
+    return { relation: "same", reason: "middles-equal" };
+  if (ma.length === 0 || mb.length === 0)
+    return { relation: "candidate", reason: "middle-absent" };
+  if (ma.length !== mb.length) {
+    return { relation: "different", reason: "middle-count-differs" };
+  }
+  for (let i = 0;i < ma.length; i++) {
+    const refused = comparePosition2(ma[i], mb[i]);
+    if (refused !== null)
+      return { relation: "different", reason: refused };
+  }
+  return { relation: "candidate", reason: "initial-agrees" };
+}
+
+// src/normalize/name-compose.ts
+var READER_RANK = ["as-parsed", "boundary", "order"];
+var VIA_ORDER = [
+  "boundary",
+  "order",
+  "middle-absent",
+  "initial",
+  "surname-part"
+];
+var MAX_READINGS2 = 4;
+var fold = (s) => nameFold2(s).toLocaleUpperCase();
+var isInitial2 = (field) => field.length === 1;
+function surnameParts2(p) {
+  const flat = (part) => part.parts.length > 0 ? part.parts.flatMap(flat) : [part.base];
+  const leaves = flat(p.surname);
+  const glued = [];
+  let held = "";
+  for (let i = 0;i < leaves.length; i++) {
+    const leaf = leaves[i];
+    if (i + 1 < leaves.length && isStandaloneNameParticle2(leaf)) {
+      held += leaf;
+      continue;
+    }
+    glued.push(held + leaf);
+    held = "";
+  }
+  const tail = glued.map(fold).filter((s) => s !== "");
+  const head = fold(p.surname.particles.join(""));
+  if (head === "")
+    return tail;
+  return tail.length === 0 ? [head] : [head + tail[0], ...tail.slice(1)];
+}
+var suffixCut2 = (p) => Math.max(1, p.givenFields().length - p.suffixes.length);
+function printAttestsOrder2(p) {
+  return /,/.test(p.nn1);
+}
+function nameReadings2(p, opts) {
+  if (!p.isPerson())
+    return [];
+  const given = p.givenFields();
+  const cut = suffixCut2(p);
+  const middles = given.slice(1, cut);
+  const suffixes = given.slice(cut);
+  const surname = surnameParts2(p);
+  const first = given[0] ?? null;
+  const asParsed = {
+    reader: "as-parsed",
+    surname,
+    first,
+    middles: middles.length === 0 ? null : middles,
+    suffixes
+  };
+  if (surname.length === 0 && first === null)
+    return [];
+  const out = [asParsed];
+  const last = middles[middles.length - 1];
+  if (surname.length === 1 && suffixes.length === 0 && last !== undefined && !isInitial2(last) && !printAttestsOrder2(p)) {
+    const kept = middles.slice(0, -1);
+    out.push({
+      reader: "boundary",
+      surname: [last, ...surname],
+      first,
+      middles: kept.length === 0 ? null : kept,
+      suffixes
+    });
+  }
+  if (!opts.orderAttested && !printAttestsOrder2(p) && surname.length === 1 && suffixes.length === 0 && middles.length === 0 && first !== null) {
+    out.push({
+      reader: "order",
+      surname: [first],
+      first: surname[0],
+      middles: null,
+      suffixes
+    });
+  }
+  return out.slice(0, MAX_READINGS2);
+}
+var readingsOf = (p, o) => nameReadings2(p, o ?? { orderAttested: printAttestsOrder2(p) });
+function meetFirst(x, y) {
+  if (x === null)
+    return y;
+  if (y === null)
+    return x;
+  return comparePosition2(x, y) === null ? x.length >= y.length ? x : y : undefined;
+}
+function meetMiddles(x, y) {
+  if (x === null)
+    return y;
+  if (y === null)
+    return x;
+  if (x.length !== y.length)
+    return;
+  const out = [];
+  for (let i = 0;i < x.length; i++) {
+    const a = x[i];
+    const b = y[i];
+    if (comparePosition2(a, b) !== null)
+      return;
+    out.push(a.length >= b.length ? a : b);
+  }
+  return out;
+}
+function meetSurname(x, y) {
+  if (subMultiset(x, y))
+    return y;
+  if (subMultiset(y, x))
+    return x;
+  return;
+}
+function meetReading2(x, y) {
+  if (x.suffixes.length !== y.suffixes.length)
+    return null;
+  if (!x.suffixes.every((s, i) => s === y.suffixes[i]))
+    return null;
+  const surname = meetSurname(x.surname, y.surname);
+  if (surname === undefined)
+    return null;
+  const first = meetFirst(x.first, y.first);
+  if (first === undefined)
+    return null;
+  const middles = meetMiddles(x.middles, y.middles);
+  if (middles === undefined)
+    return null;
+  return {
+    reader: READER_RANK.indexOf(x.reader) >= READER_RANK.indexOf(y.reader) ? x.reader : y.reader,
+    surname,
+    first,
+    middles,
+    suffixes: x.suffixes
+  };
+}
+function refinesReading2(outer, inner) {
+  const m = meetReading2(outer, inner);
+  return m !== null && sameReading2(m, inner);
+}
+function sameReading2(x, y) {
+  const list = (a, b) => a === null || b === null ? a === b : a.length === b.length && a.every((v, i) => v === b[i]);
+  return x.first === y.first && list(x.surname, y.surname) && list(x.middles, y.middles) && list(x.suffixes, y.suffixes);
+}
+function viaOf(x, y) {
+  const out = [];
+  if (x.reader !== "as-parsed")
+    out.push(x.reader);
+  if (y.reader !== "as-parsed")
+    out.push(y.reader);
+  if (x.middles === null !== (y.middles === null))
+    out.push("middle-absent");
+  const pairs = [[x.first, y.first]];
+  if (x.middles !== null && y.middles !== null && x.middles.length === y.middles.length) {
+    for (let i = 0;i < x.middles.length; i++) {
+      pairs.push([x.middles[i], y.middles[i]]);
+    }
+  }
+  for (const [l, r] of pairs) {
+    if (l === null || r === null)
+      continue;
+    if (l !== r && (isInitial2(l) || isInitial2(r)))
+      out.push("initial");
+  }
+  if (x.surname.length !== y.surname.length)
+    out.push("surname-part");
+  return out;
+}
+var orderVia = (found) => VIA_ORDER.filter((v) => found.has(v));
+var LADDER = [
+  "same",
+  "contains",
+  "overlaps",
+  "conflict"
+];
+function relateOnePair(x, y) {
+  const meet = meetReading2(x, y);
+  if (meet === null)
+    return { a: x, b: y, composition: "conflict", direction: null, meet };
+  if (sameReading2(x, y))
+    return { a: x, b: y, composition: "same", direction: null, meet };
+  if (sameReading2(meet, y)) {
+    return { a: x, b: y, composition: "contains", direction: "a-contains-b", meet };
+  }
+  if (sameReading2(meet, x)) {
+    return { a: x, b: y, composition: "contains", direction: "b-contains-a", meet };
+  }
+  return { a: x, b: y, composition: "overlaps", direction: null, meet };
+}
+var readersUsed = (p) => (p.a.reader === "as-parsed" ? 0 : 1) + (p.b.reader === "as-parsed" ? 0 : 1);
+function chooseReadingPair2(ra, rb) {
+  let best = null;
+  let bestScore = null;
+  for (const x of ra) {
+    for (const y of rb) {
+      const pair = relateOnePair(x, y);
+      const keys = [showReading2(x), showReading2(y)].sort();
+      const score = [
+        LADDER.indexOf(pair.composition),
+        readersUsed(pair),
+        keys[0],
+        keys[1]
+      ];
+      if (bestScore === null || less(score, bestScore)) {
+        best = pair;
+        bestScore = score;
+      }
+    }
+  }
+  return best;
+}
+function less(x, y) {
+  for (let i = 0;i < 4; i++) {
+    if (x[i] === y[i])
+      continue;
+    return x[i] < y[i];
+  }
+  return false;
+}
+function composeReadings2(ra, rb) {
+  const pair = chooseReadingPair2(ra, rb);
+  if (pair === null)
+    return { composition: "silent", direction: null, via: [] };
+  if (pair.composition === "conflict") {
+    return { composition: "conflict", direction: null, via: [] };
+  }
+  return {
+    composition: pair.composition,
+    direction: pair.direction,
+    via: orderVia(new Set(viaOf(pair.a, pair.b)))
+  };
+}
+function composeNames2(a, b, opts) {
+  return composeReadings2(readingsOf(a, opts?.a), readingsOf(b, opts?.b));
+}
+function meetReadings2(ra, rb) {
+  const pair = chooseReadingPair2(ra, rb);
+  if (pair === null || pair.meet === null)
+    return null;
+  return [pair.meet];
+}
+function nameMeet2(a, b, opts) {
+  return meetReadings2(readingsOf(a, opts?.a), readingsOf(b, opts?.b));
+}
+function showReading2(r) {
+  const mid = r.middles === null ? "-" : r.middles.join("<");
+  const suf = r.suffixes.length === 0 ? "" : `<${r.suffixes.join("<")}`;
+  return `${r.surname.join("-")}<<${r.first ?? "?"}|${mid}${suf}[${r.reader}]`;
+}
+var BLOCK_KEY_JOIN = "|";
+function blockKeysOfReadings2(readings) {
+  const out = new Set;
+  for (const r of readings) {
+    const initial = r.first === null ? "" : r.first[0];
+    for (const part of r.surname)
+      out.add(`${part}${BLOCK_KEY_JOIN}${initial}`);
+  }
+  return [...out].sort();
+}
+function nameBlockKeys2(p, opts) {
+  return blockKeysOfReadings2(readingsOf(p, opts));
+}
+var slotsOf = (r) => ({
+  first: r.first,
+  middles: r.middles,
+  suffixes: r.suffixes
+});
+var slotKey = (s) => `${s.first ?? "?"}|${s.middles === null ? "-" : s.middles.join("<")}|${s.suffixes.join("<")}`;
+function meetSlots(x, y) {
+  if (x.suffixes.length !== y.suffixes.length)
+    return;
+  if (!x.suffixes.every((v, i) => v === y.suffixes[i]))
+    return;
+  const first = meetFirst(x.first, y.first);
+  if (first === undefined)
+    return;
+  const middles = meetMiddles(x.middles, y.middles);
+  if (middles === undefined)
+    return;
+  return { first, middles, suffixes: x.suffixes };
+}
+function namesFeasible2(names, opts) {
+  const attester = opts?.attester ?? "as-parsed";
+  const silent = [];
+  const perPrint = [];
+  const seen = new Map;
+  for (let i = 0;i < names.length; i++) {
+    const p = names[i];
+    const rs = readingsOf(p, opts?.readings?.[i]);
+    if (rs.length === 0) {
+      silent.push(i);
+      continue;
+    }
+    const key = rs.map(showReading2).join("\x00");
+    const at = seen.get(key);
+    if (at !== undefined)
+      continue;
+    seen.set(key, i);
+    perPrint.push({ index: i, readings: rs });
+  }
+  if (perPrint.length === 0) {
+    return { feasible: false, name: null, bridge: null, silent };
+  }
+  const mayAttest = (r) => attester === "any" || r.reader === "as-parsed";
+  let bestBridge = null;
+  let bestName = null;
+  for (const cand of perPrint) {
+    for (const r of cand.readings) {
+      if (!mayAttest(r))
+        continue;
+      const folded = foldUnder(perPrint, r.surname);
+      if (folded === null)
+        continue;
+      const bridge = { index: cand.index, reader: r.reader, surname: r.surname };
+      if (bestBridge === null || rank(bridge) < rank(bestBridge)) {
+        bestBridge = bridge;
+        bestName = { reader: r.reader, surname: r.surname, ...folded };
+      }
+    }
+  }
+  return {
+    feasible: bestBridge !== null,
+    name: bestName,
+    bridge: bestBridge,
+    silent
+  };
+}
+var rank = (b) => (b.reader === "as-parsed" ? 0 : 1) * 1e9 + b.index;
+function foldUnder(prints, surname) {
+  let states = null;
+  let covered = false;
+  for (const p of prints) {
+    const usable = p.readings.filter((r) => subMultiset(r.surname, surname));
+    if (usable.length === 0)
+      return null;
+    if (usable.some((r) => r.surname.length === surname.length))
+      covered = true;
+    const next = new Map;
+    for (const r of usable) {
+      const s = slotsOf(r);
+      if (states === null) {
+        next.set(slotKey(s), s);
+        continue;
+      }
+      for (const prev of states.values()) {
+        const m = meetSlots(prev, s);
+        if (m !== undefined)
+          next.set(slotKey(m), m);
+      }
+    }
+    if (next.size === 0)
+      return null;
+    states = next;
+  }
+  if (states === null || !covered)
+    return null;
+  return [...states.values()].sort((x, y) => {
+    const mx = x.middles === null ? -1 : x.middles.length;
+    const my = y.middles === null ? -1 : y.middles.length;
+    return mx - my || (slotKey(x) < slotKey(y) ? -1 : 1);
+  })[0];
+}
+
+// src/normalize/name-kinship.ts
+var KINSHIP_VIAS2 = Object.freeze({
+  "surname-part": Object.freeze({ field: "surname", gateSafe: true }),
+  "given-variant": Object.freeze({ field: "given", gateSafe: true }),
+  "given-family": Object.freeze({ field: "given", gateSafe: true }),
+  "given-family-not-gate": Object.freeze({ field: "given", gateSafe: false }),
+  "given-maybe": Object.freeze({ field: "given", gateSafe: false }),
+  "middle-absent": Object.freeze({ field: "middle", gateSafe: true }),
+  "initial-agrees": Object.freeze({ field: "middle", gateSafe: true })
+});
+var VIA_ORDER2 = Object.freeze(Object.keys(KINSHIP_VIAS2));
+var different = (reason) => ({
+  relation: "different",
+  via: [],
+  reason,
+  gateSafe: false
+});
+function surnamePartOf(a, b) {
+  const pa = surnameParts2(a);
+  const pb = surnameParts2(b);
+  if (pa.length === pb.length)
+    return false;
+  const [short, long] = pa.length < pb.length ? [pa, pb] : [pb, pa];
+  return subMultiset(short, long);
+}
+function createNameKinship2(options = {}) {
+  const providers = Object.freeze([
+    ...options.given ?? [givenFamilyTable2, givenFamilyList2]
+  ]);
+  const givenVia = (x, y) => {
+    const [lo, hi] = x < y ? [x, y] : [y, x];
+    for (const provider of providers) {
+      const via = provider(lo, hi);
+      if (via !== null)
+        return via;
+    }
+    return null;
+  };
+  return (a, b) => {
+    if (!a.isPerson() || !b.isPerson())
+      return different("not-a-person");
+    const found = new Set;
+    if (a.surnameKey() !== b.surnameKey()) {
+      if (!surnamePartOf(a, b))
+        return different("surname-differs");
+      found.add("surname-part");
+    }
+    const ga = a.givenFields()[0];
+    const gb = b.givenFields()[0];
+    if (ga === undefined || gb === undefined)
+      return different("given-differs");
+    if (ga !== gb) {
+      const via = givenVia(ga, gb);
+      if (via === null)
+        return different("given-differs");
+      found.add(via);
+    }
+    const tail = tailRelation(a, b);
+    if (tail.relation === "different")
+      return different(tail.reason);
+    if (tail.relation === "candidate")
+      found.add(tail.reason);
+    const via = VIA_ORDER2.filter((v) => found.has(v));
+    return {
+      relation: via.length === 0 ? "same" : "candidate",
+      via,
+      reason: tail.reason,
+      gateSafe: via.every((v) => KINSHIP_VIAS2[v].gateSafe)
+    };
+  };
+}
+var nameKinship2 = createNameKinship2();
+
+// src/normalize/name-compare.ts
+function nameCompare2(a, b, dop) {
+  const x = levelOf2(a, dop);
+  const y = levelOf2(b, dop);
+  if (x < y)
+    return -1;
+  return x > y ? 1 : 0;
+}
+function probablySame2(a, b, dop) {
+  if (!a.isPerson() || !b.isPerson())
+    return false;
+  if (dop === "nn5")
+    return nameRelation2(a, b).relation !== "different";
+  return levelOf2(a, dop) === levelOf2(b, dop);
+}
+function slotOf(name, dop) {
+  return name.isPerson() ? levelOf2(name, dop) : null;
+}
+var loner = 0;
+var lonerSlot = () => `\x1F\x1F${loner++}`;
+function createNameSet2(dop) {
+  const held = new Map;
+  const set = {
+    dop,
+    get size() {
+      return held.size;
+    },
+    get: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? undefined : held.get(slot);
+    },
+    has: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? false : held.has(slot);
+    },
+    add(name) {
+      const slot = slotOf(name, dop);
+      if (slot === null)
+        held.set(lonerSlot(), name);
+      else if (!held.has(slot))
+        held.set(slot, name);
+      return this;
+    },
+    delete: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? false : held.delete(slot);
+    },
+    clear: () => held.clear(),
+    values: () => held.values(),
+    [Symbol.iterator]: () => held.values()
+  };
+  return set;
+}
+function createNameMap2(dop, entries) {
+  const held = new Map;
+  const map = {
+    dop,
+    get size() {
+      return held.size;
+    },
+    get: (name) => {
+      const key = slotOf(name, dop);
+      return key === null ? undefined : held.get(key)?.[1];
+    },
+    has: (name) => {
+      const key = slotOf(name, dop);
+      return key === null ? false : held.has(key);
+    },
+    set(name, value) {
+      const key = slotOf(name, dop);
+      const slot = key === null ? undefined : held.get(key);
+      if (slot === undefined)
+        held.set(key ?? lonerSlot(), [name, value]);
+      else
+        slot[1] = value;
+      return this;
+    },
+    delete: (name) => {
+      const key = slotOf(name, dop);
+      return key === null ? false : held.delete(key);
+    },
+    clear: () => held.clear(),
+    *keys() {
+      for (const [name] of held.values())
+        yield name;
+    },
+    *values() {
+      for (const [, value] of held.values())
+        yield value;
+    },
+    *entries() {
+      for (const slot of held.values())
+        yield [slot[0], slot[1]];
+    },
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+  for (const [name, value] of entries ?? [])
+    map.set(name, value);
+  return map;
+}
+function kinshipBuckets(name) {
+  return [...new Set([name.surnameKey(), ...surnameParts2(name)])];
+}
+var RELATION_RANK = {
+  same: 0,
+  candidate: 1,
+  different: 2
+};
+function createNameIndex2(dop, options = {}) {
+  const kinship = options.kinship ?? nameKinship2;
+  const map = createNameMap2(dop);
+  const filed = new Map;
+  const buckets = new Map;
+  let seq = 0;
+  const file = (slot, name) => {
+    filed.set(slot, { name, seq: seq++ });
+    for (const key of kinshipBuckets(name)) {
+      const slots = buckets.get(key);
+      if (slots === undefined)
+        buckets.set(key, new Set([slot]));
+      else
+        slots.add(slot);
+    }
+  };
+  const unfile = (slot) => {
+    const held = filed.get(slot);
+    if (held === undefined)
+      return;
+    filed.delete(slot);
+    for (const key of kinshipBuckets(held.name)) {
+      const slots = buckets.get(key);
+      slots?.delete(slot);
+      if (slots?.size === 0)
+        buckets.delete(key);
+    }
+  };
+  const index = {
+    dop,
+    get size() {
+      return map.size;
+    },
+    get: (name) => map.get(name),
+    has: (name) => map.has(name),
+    set(name, value) {
+      const slot = slotOf(name, dop);
+      if (slot !== null && !filed.has(slot))
+        file(slot, name);
+      map.set(name, value);
+      return this;
+    },
+    delete: (name) => {
+      const slot = slotOf(name, dop);
+      if (slot !== null)
+        unfile(slot);
+      return map.delete(name);
+    },
+    clear: () => {
+      filed.clear();
+      buckets.clear();
+      map.clear();
+    },
+    keys: () => map.keys(),
+    values: () => map.values(),
+    entries: () => map.entries(),
+    [Symbol.iterator]: () => map.entries(),
+    related(name) {
+      const slots = new Set;
+      for (const key of kinshipBuckets(name)) {
+        for (const slot of buckets.get(key) ?? [])
+          slots.add(slot);
+      }
+      const found = [];
+      for (const slot of slots) {
+        const held = filed.get(slot);
+        if (held === undefined)
+          continue;
+        const k = kinship(name, held.name);
+        if (k.relation === "different")
+          continue;
+        found.push({
+          name: held.name,
+          value: map.get(held.name),
+          kinship: k,
+          seq: held.seq
+        });
+      }
+      found.sort((x, y) => RELATION_RANK[x.kinship.relation] - RELATION_RANK[y.kinship.relation] || x.seq - y.seq);
+      return found.map(({ name: n, value, kinship: k }) => ({ name: n, value, kinship: k }));
+    }
+  };
+  for (const [name, value] of options.entries ?? [])
+    index.set(name, value);
+  return index;
+}
+function createNameClusters2(dop, linkage) {
+  if (dop === "nn5") {
+    throw new Error('createNameClusters at nn5 is unimplemented: a linkage is defined over a distance and NN5 answers a relation. Use nameRelation / probablySame(a, b, "nn5"); see docs/NAME-NORMALIZATION.md § NN5 — the middle-name relation.');
+  }
+  const transitive = dop;
+  const held = new Map;
+  const out = {
+    dop,
+    linkage,
+    get size() {
+      return held.size;
+    },
+    add(name) {
+      const key = slotOf(name, transitive);
+      const cluster = key === null ? undefined : held.get(key);
+      if (cluster === undefined)
+        held.set(key ?? lonerSlot(), [name]);
+      else
+        cluster.push(name);
+      return this;
+    },
+    clusterOf: (name) => {
+      const key = slotOf(name, transitive);
+      return key === null ? undefined : held.get(key);
+    },
+    clusters: () => [...held.values()],
+    [Symbol.iterator]: () => held.values()
+  };
+  return out;
+}
+// src/normalize/name-infeasible.ts
+var INFEASIBLE_CLASSES2 = ["merge?", "spelling", "rule-gap"];
+function editDistance2(a, b) {
+  const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  const cur = new Array(b.length + 1).fill(0);
+  for (let i = 1;i <= a.length; i++) {
+    cur[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const sub = prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      cur[j] = Math.min(sub, prev[j] + 1, cur[j - 1] + 1);
+    }
+    for (let j = 0;j <= b.length; j++)
+      prev[j] = cur[j];
+  }
+  return prev[b.length];
+}
+function nearSpelling2(a, b) {
+  if (a[0] !== b[0])
+    return false;
+  const budget = Math.max(a.length, b.length) >= 6 ? 2 : 1;
+  return editDistance2(a, b) <= budget;
+}
+var compoundGiven2 = (a, b) => {
+  const [short, long] = a.length <= b.length ? [a, b] : [b, a];
+  return long.startsWith(short) && long.length - short.length >= 3;
+};
+function middleForm2(p) {
+  const given = p.givenFields();
+  return given.slice(1, Math.max(1, given.length - p.suffixes.length)).join("<");
+}
+var allPairs = (xs, f) => {
+  for (let i = 0;i < xs.length; i++) {
+    for (let j = i + 1;j < xs.length; j++) {
+      if (!f(xs[i], xs[j]))
+        return false;
+    }
+  }
+  return true;
+};
+var anyPair = (xs, f) => {
+  for (let i = 0;i < xs.length; i++) {
+    for (let j = i + 1;j < xs.length; j++) {
+      if (f(xs[i], xs[j]))
+        return true;
+    }
+  }
+  return false;
+};
+function infeasibleClass2(names) {
+  const surnames = [...new Set(names.map((p) => surnameParts2(p).join("-")))];
+  const firsts = [...new Set(names.map((p) => p.givenFields()[0] ?? ""))];
+  if (firsts.length > 1) {
+    if (anyPair(firsts, compoundGiven2))
+      return "rule-gap";
+    if (allPairs(firsts, nearSpelling2))
+      return "spelling";
+    return "merge?";
+  }
+  if (surnames.length > 1) {
+    if (allPairs(surnames, nearSpelling2))
+      return "spelling";
+    return "merge?";
+  }
+  const middles = [...new Set(names.map(middleForm2))].filter((f) => f !== "");
+  if (middles.length > 1 && allPairs(middles, nearSpelling2))
+    return "spelling";
+  return "rule-gap";
+}
+// src/normalize/person-list.ts
+var JOINERS = new Set(["&", "and", "+"]);
+function isListJoiner2(field) {
+  return JOINERS.has(field.trim().toLocaleLowerCase());
+}
+var SEPARATOR = /\s*[&;,]\s*|\s+\/\s+|\s+and\s+|\s+\+\s+/giu;
+var LETTERS = new Set([
+  "adcrg",
+  "adcg",
+  "adcrn",
+  "bg",
+  "bgcrg",
+  "odcrn",
+  "sdcrg",
+  "tcg",
+  "tcrg",
+  "tmcrn",
+  "tmrf",
+  "phd",
+  "esq",
+  "jd"
+]);
+var TITLES = new Set(["dr", "mr", "mrs", "ms", "miss"]);
+var MAX_NAME_TOKENS = 4;
+var EDGE = /^[("“'‘[]+|[)"”'’\].:]+$/gu;
+var bareOf = (token) => token.replace(EDGE, "").split("/")[0].replace(/\./gu, "");
+function isLetters(token, begun, allCaps) {
+  if (/\p{N}/u.test(token))
+    return true;
+  const bare = bareOf(token);
+  if (bare === "" || LETTERS.has(bare.toLocaleLowerCase()))
+    return true;
+  return begun && !allCaps && bare.length >= 2 && /^\p{Lu}+$/u.test(bare);
+}
+function nameTokens(member, allCaps) {
+  let out = [];
+  for (const t of member.split(/\s+/u)) {
+    if (t === "")
+      continue;
+    if (t.endsWith(":")) {
+      out = [];
+      continue;
+    }
+    if (isLetters(t, out.length > 0, allCaps)) {
+      if (out.length > 0)
+        break;
+      continue;
+    }
+    if (out.length === 0 && TITLES.has(bareOf(t).toLocaleLowerCase()))
+      continue;
+    out.push(t);
+  }
+  return out;
+}
+var surnamePrint = (p) => [...p.surname.particles, p.surname.base].filter((s) => s !== "").join(" ");
+function personList2(print, factory = defaultPersonNameFactory2()) {
+  const allCaps = !/\p{Ll}/u.test(print);
+  const members = print.split(SEPARATOR).map((m) => nameTokens(m, allCaps)).filter((tokens) => tokens.length > 0);
+  if (members.length === 0)
+    return [];
+  const whole = () => [
+    { printed: print.trim(), name: factory.parse(print, "given-first"), surnameFrom: null }
+  ];
+  if (members.some((tokens) => tokens.length > MAX_NAME_TOKENS))
+    return whole();
+  const out = [];
+  let pending = [];
+  for (const tokens of members) {
+    const printed = tokens.join(" ");
+    if (tokens.length === 1) {
+      pending.push(printed);
+      continue;
+    }
+    const name = factory.parse(printed, "given-first");
+    const surname = name.isPerson() ? surnamePrint(name) : "";
+    if (surname !== "")
+      for (const given of pending)
+        out.push({
+          printed: given,
+          name: factory.parse(`${given} ${surname}`, "given-first"),
+          surnameFrom: surname
+        });
+    pending = [];
+    out.push({ printed, name, surnameFrom: null });
+  }
+  return out;
+}
+// src/normalize/block-keys.ts
+function blockLetters(surname) {
+  return surname.toUpperCase().replace(/[^A-Z]/g, "");
+}
+function firstLetter(s) {
+  const m = s.match(/[A-Za-z]/);
+  return m ? m[0].toUpperCase() : null;
+}
+function surnameBlock2(surname) {
+  return blockLetters(surname) || null;
+}
+function initialsBlock2(given, surname) {
+  const first = firstLetter(given);
+  const last = firstLetter(blockLetters(surname));
+  return first && last ? first + last : null;
+}
+function metaphoneBlocks2(surname) {
+  const letters = blockLetters(surname);
+  if (!letters)
+    return [];
+  const [primary, secondary] = doubleMetaphone2(letters);
+  if (!primary)
+    return [];
+  return secondary && secondary !== primary ? [primary, secondary] : [primary];
+}
+// src/normalize/name-columns.ts
+var NAME_LEVEL_COLUMNS2 = [
+  "nn0",
+  "nn1",
+  "nn2",
+  "nn3",
+  "nn4"
+];
+var NAME_COLUMNS2 = [
+  ...NAME_LEVEL_COLUMNS2,
+  "surname_key",
+  "given_key",
+  "blk_surname",
+  "blk_initials",
+  "blk_metaphone",
+  "blk_metaphone_alt"
+];
+function nameColumns2(name) {
+  const person = name.isPerson();
+  const level = (dop) => person ? name[dop] : null;
+  const surname = person ? name.surnameKey() : "";
+  const [metaphone, metaphoneAlt] = metaphoneBlocks2(surname);
+  return {
+    nn0: level("nn0"),
+    nn1: level("nn1"),
+    nn2: level("nn2"),
+    nn3: level("nn3"),
+    nn4: level("nn4"),
+    surname_key: surname || null,
+    given_key: person && name.givenName() || null,
+    blk_surname: surnameBlock2(surname),
+    blk_initials: person ? initialsBlock2(name.givenFields()[0] ?? "", surname) : null,
+    blk_metaphone: metaphone ?? null,
+    blk_metaphone_alt: metaphoneAlt ?? null
+  };
+}
+// src/normalize/name-format.ts
+var NAME_FORMATS2 = ["First Last", "Last, First", "Last First"];
+function nameFormatOrder2(verdict) {
+  if (verdict === "unknown")
+    return "unknown";
+  return verdict === "First Last" ? "given-first" : "surname-first";
+}
+var ORDER_READINGS2 = [
+  "comma",
+  "given-first:two-token",
+  "surname-first:two-token",
+  "given-first:one-token",
+  "surname-first:one-token"
+];
+var HAS_LETTER = /\p{L}/u;
+var SPACED_DASH = /\s[-–—]\s/gu;
+function isPlaceField(field, flagsOf) {
+  const words = field.split(/[\s,/]+/u).map((w) => w.replace(/^[.(]+|[.)]+$/gu, "")).filter((w) => w !== "");
+  return words.length > 0 && words.every((w) => isPlaceWordFlags(flagsOf(w) ?? ""));
+}
+function givenOnly(flags) {
+  return flags !== null && isGiven2(flags) && !isSurname2(flags) && !isAmbiguous2(flags);
+}
+function surnameOnly(flags) {
+  return flags !== null && isSurname2(flags) && !isGiven2(flags) && !isAmbiguous2(flags);
+}
+function tokenOrder(a, b) {
+  if (givenOnly(a) && surnameOnly(b))
+    return "given-first:two-token";
+  if (surnameOnly(a) && givenOnly(b))
+    return "surname-first:two-token";
+  if (a !== null && b !== null)
+    return;
+  if (b === null && givenOnly(a))
+    return "given-first:one-token";
+  if (a === null && surnameOnly(b))
+    return "given-first:one-token";
+  if (b === null && surnameOnly(a))
+    return "surname-first:one-token";
+  if (a === null && givenOnly(b))
+    return "surname-first:one-token";
+  return;
+}
+function orderReadingPoints(r) {
+  return r === "given-first:two-token" || r === "given-first:one-token" ? "given-first" : "surname-first";
+}
+var flagLookups = new WeakMap;
+function flagsOfLexicon(lexicon) {
+  let f = flagLookups.get(lexicon);
+  if (f === undefined) {
+    f = (t) => lexicon.getNameFlags(t);
+    flagLookups.set(lexicon, f);
+  }
+  return f;
+}
+function readNameCell2(cell, options = {}) {
+  const print = typeof cell === "string" ? cell : cell.name;
+  const rowSchool = typeof cell === "string" ? "" : (cell.school ?? "").replace(/\s+/gu, " ").trim();
+  const flagsOf = flagsOfLexicon(options.lexicon ?? Lexicon2.default());
+  const readLocation = options.readLocation ?? true;
+  const skip = (skipped) => ({
+    print,
+    skipped,
+    name: "",
+    commas: [],
+    tokens: 0
+  });
+  let s = print.replace(/\s+/gu, " ").trim();
+  if (s === "")
+    return skip("empty");
+  if (isNoNamePrint2(s) || isPlaceholderPrint2(s))
+    return skip("no-name");
+  if (isTeamPrint2(s))
+    return skip("team");
+  const places = [];
+  const commas = [];
+  let school;
+  if (readLocation) {
+    const colon = s.indexOf(":");
+    if (colon > 0) {
+      let tail = s.slice(colon + 1).trim();
+      s = s.slice(0, colon).trim();
+      const tailPlaces = [];
+      for (;; ) {
+        if (isPlaceField(tail, flagsOf)) {
+          tailPlaces.unshift(tail);
+          for (const _ of tail.matchAll(/,/gu))
+            commas.push("place");
+          tail = "";
+          break;
+        }
+        const at = tail.lastIndexOf(",");
+        if (at <= 0)
+          break;
+        const field = tail.slice(at + 1).trim();
+        if (field === "" || !isPlaceField(field, flagsOf))
+          break;
+        tailPlaces.unshift(field);
+        commas.push("place");
+        tail = tail.slice(0, at).trim();
+      }
+      if (tailPlaces.length > 0)
+        places.unshift(tailPlaces.join(", "));
+      if (HAS_LETTER.test(tail))
+        school = tail;
+    }
+    const paren = /\s*\(([^()]*)\)\s*$/u.exec(s);
+    if (paren !== null && paren.index > 0 && isPlaceField(paren[1], flagsOf)) {
+      places.unshift(paren[1].trim());
+      s = s.slice(0, paren.index).trim();
+    }
+    for (;; ) {
+      const dashes = [...s.matchAll(SPACED_DASH)];
+      const dash = dashes[dashes.length - 1];
+      if (dash === undefined || dash.index <= 0)
+        break;
+      const tail = s.slice(dash.index + dash[0].length).trim();
+      if (!isPlaceField(tail, flagsOf))
+        break;
+      places.unshift(tail);
+      for (const _ of tail.matchAll(/,/gu))
+        commas.push("place");
+      s = s.slice(0, dash.index).trim();
+    }
+    for (;; ) {
+      const at = s.lastIndexOf(",");
+      if (at <= 0)
+        break;
+      const tail = s.slice(at + 1).trim();
+      if (tail === "" || !isPlaceField(tail, flagsOf))
+        break;
+      const head = s.slice(0, at).trim();
+      if (tokenize(head.replace(/,/gu, " ")).filter((t) => HAS_LETTER.test(t)).length < 2)
+        break;
+      places.unshift(tail);
+      commas.push("place");
+      s = head;
+    }
+  }
+  s = s.replace(/\([^()]*\)/gu, " ").replace(/\s+/gu, " ").trim();
+  if (!HAS_LETTER.test(s)) {
+    if (places.length === 0)
+      return skip("no-name");
+    s = "";
+  }
+  if (school === undefined && rowSchool !== "" && HAS_LETTER.test(rowSchool)) {
+    const at = s.toLocaleLowerCase().lastIndexOf(rowSchool.toLocaleLowerCase());
+    if (at > 0 && at + rowSchool.length === s.length && /[\s,;:-]/u.test(s[at - 1] ?? "")) {
+      const head = s.slice(0, at);
+      if (HAS_LETTER.test(head)) {
+        school = s.slice(at);
+        if (/,\s*$/u.test(head))
+          commas.push("glue");
+        s = head.replace(/[\s,;:-]+$/u, "");
+      }
+    }
+  }
+  if (school === undefined && options.segmenter && s !== "") {
+    const words = s.split(" ");
+    const kept = [];
+    const clean = [];
+    for (const [i, w] of words.entries()) {
+      const c = w.replace(/^[,;.]+|[,;.]+$/gu, "");
+      if (!HAS_LETTER.test(c))
+        continue;
+      kept.push(i);
+      clean.push(c);
+    }
+    if (clean.length >= 2) {
+      const seg = options.segmenter.segmentTokens(clean);
+      if (seg.person.length > 0 && seg.school.length > 0) {
+        const cut = kept[seg.person.length];
+        school = seg.school.join(" ");
+        if (seg.location.length > 0)
+          places.unshift(seg.location.join(" "));
+        const tail = words.slice(cut).join(" ");
+        for (const _ of tail.matchAll(/,/gu))
+          commas.push("glue");
+        s = words.slice(0, cut).join(" ").replace(/[\s,;-]+$/u, "");
+        if (/,\s*$/u.test(words.slice(0, cut).join(" ")))
+          commas.push("glue");
+      }
+    }
+  }
+  let comma = commaReading2(s);
+  if (comma === "separator" && readLocation && options.placeColumn) {
+    const at = s.lastIndexOf(",");
+    const head = s.slice(0, at).trim();
+    const tail = s.slice(at + 1).trim();
+    const headTokens = tokenize(head).filter((t) => HAS_LETTER.test(t));
+    const tailTokens = tokenize(tail).filter((t) => HAS_LETTER.test(t));
+    const givenInTail = tailTokens.some((t) => {
+      const f = flagsOf(t);
+      return f !== null && isGiven2(f);
+    });
+    if (headTokens.length >= 2 && tailTokens.length > 0 && !givenInTail) {
+      places.push(tail);
+      commas.push("place");
+      s = head;
+      comma = commaReading2(s);
+    }
+  }
+  if (comma !== "none")
+    commas.push(comma);
+  const out = {
+    print,
+    name: s,
+    commas,
+    tokens: 0,
+    ...school !== undefined ? { school } : {},
+    ...places.length > 0 ? { location: places.join(", ") } : {}
+  };
+  const tokens = tokenize(s.replace(/,/gu, " ")).filter((t) => HAS_LETTER.test(t) && !isNameSuffix(t));
+  out.tokens = tokens.length;
+  if (comma === "separator") {
+    out.order = "comma";
+  } else if (comma !== "glue" && comma !== "particle" && tokens.length === 2) {
+    const order = tokenOrder(flagsOf(tokens[0]), flagsOf(tokens[1]));
+    if (order !== undefined)
+      out.order = order;
+  }
+  if (out.order !== undefined)
+    out.orderPoints = orderReadingPoints(out.order);
+  return out;
+}
+function logGamma(x) {
+  if (x < 0.5)
+    return Math.log(Math.PI / Math.sin(Math.PI * x)) - logGamma(1 - x);
+  const c = [
+    0.9999999999998099,
+    676.5203681218851,
+    -1259.1392167224028,
+    771.3234287776531,
+    -176.6150291621406,
+    12.507343278686905,
+    -0.13857109526572012,
+    0.000009984369578019572,
+    0.00000015056327351493116
+  ];
+  const z = x - 1;
+  let a = c[0];
+  const t = z + 7.5;
+  for (let i = 1;i < 9; i++)
+    a += c[i] / (z + i);
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(a);
+}
+function binomialTail(k, n, p) {
+  if (k <= 0)
+    return 1;
+  if (p <= 0)
+    return 0;
+  if (p >= 1)
+    return 1;
+  const lp = Math.log(p);
+  const lq = Math.log1p(-p);
+  let tail = 0;
+  for (let j = k;j <= n; j++)
+    tail += Math.exp(logGamma(n + 1) - logGamma(j + 1) - logGamma(n - j + 1) + j * lp + (n - j) * lq);
+  return Math.min(1, tail);
+}
+function posterior(logs) {
+  const m = Math.max(...logs);
+  const e = logs.map((l) => Math.exp(l - m));
+  const z = e.reduce((x, y) => x + y, 0);
+  return e.map((x) => x / z);
+}
+var NAME_FORMAT_MODEL = {
+  comma: { "First Last": 0.00001237, "Last, First": 0.9989, "Last First": 0.0009921 },
+  surnameFirst: {
+    "First Last": { twoToken: 0.0008603, oneToken: 0.02476 },
+    "Last, First": { twoToken: 0.5, oneToken: 0.0625 },
+    "Last First": { twoToken: 0.9972, oneToken: 0.9604 }
+  },
+  dissent: { "First Last": 0.004387, "Last, First": 0.0004406, "Last First": 0.01895 },
+  smoothing: 0.25,
+  mixedTail: 0.01,
+  school: { recall: 0.9945, falseRate: 0.0248 },
+  location: { recall: 0.6772, falseRate: 0.0001503 }
+};
+var DEFAULT_NAME_FORMAT_THRESHOLD2 = 0.95;
+function orderCounts(readings) {
+  const counts = ORDER_READINGS2.map(() => 0);
+  for (const r of readings)
+    if (r.order !== undefined)
+      counts[ORDER_READINGS2.indexOf(r.order)]++;
+  return counts;
+}
+function orderLogLikelihood(counts, read, model, f) {
+  const [comma, gf2, sf2, gf1, sf1] = counts;
+  const k = model.comma[f];
+  const s = model.surnameFirst[f];
+  return comma * Math.log(k) + (read - comma) * Math.log1p(-k) + sf2 * Math.log(s.twoToken) + gf2 * Math.log1p(-s.twoToken) + sf1 * Math.log(s.oneToken) + gf1 * Math.log1p(-s.oneToken);
+}
+function partProbability(k, n, reader) {
+  if (n === 0)
+    return 0.5;
+  const steps = 200;
+  let lo = 0;
+  let hi = 0;
+  const logs = [];
+  for (let i = 0;i < steps; i++) {
+    const theta = (i + 0.5) / steps;
+    const q = theta * reader.recall + (1 - theta) * reader.falseRate;
+    logs.push(k * Math.log(q) + (n - k) * Math.log1p(-q));
+  }
+  const m = Math.max(...logs);
+  for (const [i, l] of logs.entries()) {
+    const w = Math.exp(l - m);
+    if ((i + 0.5) / steps >= 0.5)
+      hi += w;
+    else
+      lo += w;
+  }
+  return hi / (lo + hi);
+}
+function scoreReadings(readings, model, threshold, schoolRead) {
+  const evidence = {
+    prints: readings.length,
+    skipped: { empty: 0, "no-name": 0, team: 0 },
+    separatorCommas: 0,
+    discountedCommas: { place: 0, glue: 0, trailing: 0, suffix: 0, particle: 0 },
+    lexicon: {
+      "given-first:two-token": 0,
+      "surname-first:two-token": 0,
+      "given-first:one-token": 0,
+      "surname-first:one-token": 0
+    },
+    unread: 0,
+    school: schoolRead ? 0 : null,
+    location: 0
+  };
+  let read = 0;
+  for (const r of readings) {
+    if (r.skipped !== undefined) {
+      evidence.skipped[r.skipped]++;
+      continue;
+    }
+    read++;
+    for (const c of r.commas) {
+      if (c === "separator")
+        evidence.separatorCommas++;
+      else if (c !== "none")
+        evidence.discountedCommas[c]++;
+    }
+    if (r.order === undefined)
+      evidence.unread++;
+    else if (r.order !== "comma")
+      evidence.lexicon[r.order]++;
+    if (r.school !== undefined && evidence.school !== null)
+      evidence.school++;
+    if (r.location !== undefined)
+      evidence.location++;
+  }
+  const counts = orderCounts(readings);
+  const oriented = counts.reduce((a, b) => a + b, 0);
+  const smooth = (x, n, k) => n + model.smoothing === 0 ? x : (n * x + model.smoothing / k) / (n + model.smoothing);
+  const p = posterior(NAME_FORMATS2.map((f) => orderLogLikelihood(counts, read, model, f))).map((x) => smooth(x, oriented, NAME_FORMATS2.length));
+  const probabilities = Object.fromEntries(NAME_FORMATS2.map((f, i) => [f, p[i]]));
+  let best = 0;
+  for (let i = 1;i < p.length; i++)
+    if (p[i] > p[best])
+      best = i;
+  const leading = NAME_FORMATS2[best];
+  const against = nameFormatOrder2(leading) === "given-first" ? "surname-first" : "given-first";
+  const dissent = readings.filter((r) => r.orderPoints === against);
+  const mixed = dissent.length > 0 && binomialTail(dissent.length, oriented, model.dissent[leading]) < model.mixedTail;
+  const verdict = !mixed && p[best] >= threshold ? leading : "unknown";
+  return {
+    probabilities,
+    verdict,
+    hasSchool: evidence.school === null ? null : smooth(partProbability(evidence.school, read, model.school), read, 2),
+    hasLocation: smooth(partProbability(evidence.location, read, model.location), read, 2),
+    mixed,
+    evidence,
+    dissent,
+    readings: [...readings]
+  };
+}
+function deriveNameFormat2(prints, options = {}) {
+  const cells = [...prints];
+  const threshold = options.threshold ?? DEFAULT_NAME_FORMAT_THRESHOLD2;
+  const schoolRead = Boolean(options.segmenter) || cells.some((c) => typeof c !== "string" && Boolean(c.school));
+  const first = scoreReadings(cells.map((c) => readNameCell2(c, options)), NAME_FORMAT_MODEL, threshold, schoolRead);
+  if (first.hasLocation <= 0.5 || options.readLocation === false || options.placeColumn)
+    return first;
+  return scoreReadings(cells.map((c) => readNameCell2(c, { ...options, placeColumn: true })), NAME_FORMAT_MODEL, threshold, schoolRead);
+}
+export { repairMojibake2, comparePosition2, nameRelation2, MAX_READINGS2, surnameParts2, printAttestsOrder2, nameReadings2, meetReading2, refinesReading2, sameReading2, chooseReadingPair2, composeReadings2, composeNames2, meetReadings2, nameMeet2, showReading2, blockKeysOfReadings2, nameBlockKeys2, namesFeasible2, KINSHIP_VIAS2, createNameKinship2, nameKinship2, nameCompare2, probablySame2, createNameSet2, createNameMap2, createNameIndex2, createNameClusters2, INFEASIBLE_CLASSES2, editDistance2, nearSpelling2, compoundGiven2, middleForm2, infeasibleClass2, isListJoiner2, personList2, surnameBlock2, initialsBlock2, metaphoneBlocks2, NAME_LEVEL_COLUMNS2, NAME_COLUMNS2, nameColumns2, NAME_FORMATS2, nameFormatOrder2, ORDER_READINGS2, readNameCell2, DEFAULT_NAME_FORMAT_THRESHOLD2, deriveNameFormat2 };
+
+//# debugId=3A882E8BB4656FA364756E2164756E21
+//# sourceMappingURL=index-n6fpj92s.js.map