@finbheara/domain 0.0.0-stage → 0.2.0

package/dist/school.js

@@ -0,0 +1,2269 @@
+import {
+  place2,
+  isPlaceToken2,
+  countryCodeOf2,
+  areAllPlaceTokens2,
+  placeRelation2,
+  sameReading2
+} from "./chunks/place-qbp3xfb4.js";
+
+import { normalizeApostrophes } from "@finbheara/names/lexicon";
+import { SURNAME_SEPARATOR, lexiconKey, titleCaseNamePart } from "@finbheara/names/normalize";
+import { personName } from "@finbheara/names/normalize";
+
+import { placeholderOf } from "@finbheara/names/normalize";
+var SCHOOL_NAME_EXCEPTIONS = [
+  {
+    phrase: "the academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "theacademy"
+  },
+  {
+    phrase: "the academy irish dance co",
+    scope: "label",
+    as: "NAME_PART",
+    token: "theacademy"
+  },
+  {
+    phrase: "rhythm of ireland",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "rhythmofireland"
+  },
+  {
+    phrase: "irish dance center",
+    scope: "label",
+    as: "NAME_PART",
+    token: "irishdancecenter"
+  },
+  {
+    phrase: "the irish dance center",
+    scope: "label",
+    as: "NAME_PART",
+    token: "irishdancecenter"
+  },
+  {
+    phrase: "the irish dance academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "theirishdanceacademy"
+  },
+  {
+    phrase: "irish dance academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "theirishdanceacademy"
+  },
+  {
+    phrase: "the irish dance company",
+    scope: "label",
+    as: "NAME_PART",
+    token: "theirishdancecompany"
+  },
+  {
+    phrase: "gra na rince",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "granarince"
+  },
+  {
+    phrase: "clann na cara",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "clannnacara"
+  },
+  {
+    phrase: "rince academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "rinceacademy"
+  },
+  {
+    phrase: "i d a s",
+    scope: "label",
+    as: "NAME_PART",
+    token: "idas"
+  },
+  {
+    phrase: "ml dance academy",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "mldanceacademy"
+  },
+  {
+    phrase: "cm dance",
+    scope: "label",
+    as: "NAME_PART",
+    token: "cmdance"
+  },
+  {
+    phrase: "traditional irish dance academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "traditionalirishdanceacademy"
+  },
+  {
+    phrase: "irish dance centre",
+    scope: "label",
+    as: "NAME_PART",
+    token: "irishdancecenter"
+  },
+  {
+    phrase: "tj academy",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "tjacademy"
+  },
+  {
+    phrase: "m d l academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "mdlacademy"
+  },
+  {
+    phrase: "wa academy",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "waacademy"
+  },
+  {
+    phrase: "fd academy",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "fdacademy"
+  },
+  {
+    phrase: "em academy",
+    scope: "label",
+    as: "NAME_PART",
+    token: "emacademy"
+  },
+  {
+    phrase: "aoibhneas an rince",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "aoibhneasanrince"
+  },
+  {
+    phrase: "an rince mor",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "anrincemor"
+  },
+  {
+    phrase: "clan rince",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "clanrince"
+  },
+  {
+    phrase: "acadamh rince",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "acadamhrince"
+  },
+  {
+    phrase: "spreagadh na rince",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "spreagadhnarince"
+  },
+  {
+    phrase: "clann na rince",
+    scope: "label",
+    as: "NAME_PART",
+    token: "clannnarince"
+  },
+  {
+    phrase: "mise eire",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "miseeire"
+  },
+  {
+    phrase: "reel eire",
+    scope: "phrase",
+    as: "NAME_PART",
+    token: "reeleire"
+  }
+];
+var EXCEPTIONS_BY_LENGTH = [
+  ...SCHOOL_NAME_EXCEPTIONS
+].sort((a, b) => b.phrase.length - a.phrase.length);
+var NOT_A_SCHOOL = [
+  {
+    pattern: "north west regional council",
+    kind: "exact",
+    reason: "organization"
+  },
+  {
+    pattern: "^#\\s*\\d+$",
+    kind: "regex",
+    reason: "placeholder"
+  },
+  {
+    pattern: "cce other",
+    kind: "exact",
+    reason: "placeholder"
+  },
+  {
+    pattern: "^x{4,}$",
+    kind: "regex",
+    reason: "placeholder"
+  },
+  {
+    pattern: "^.+['’]s team$",
+    kind: "regex",
+    reason: "not-a-name"
+  },
+  {
+    pattern: "^\\d+(st|nd|rd|th) team up$",
+    kind: "regex",
+    reason: "not-a-name"
+  },
+  {
+    pattern: "^[abc] team$",
+    kind: "regex",
+    reason: "not-a-name"
+  },
+  {
+    pattern: "^[^\\p{L}]*$",
+    kind: "regex",
+    reason: "not-a-name"
+  }
+];
+var INVISIBLE = /[​‌‍ ]/g;
+var COMBINING = /[̀-ͯ]/g;
+function normalizeForRefusal(print) {
+  return print.replace(INVISIBLE, " ").normalize("NFD").replace(COMBINING, "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+var PLACEHOLDER_ROWS = new Map;
+function placeholderRow(p) {
+  let row = PLACEHOLDER_ROWS.get(p);
+  if (row === undefined)
+    PLACEHOLDER_ROWS.set(p, row = { pattern: p.print, kind: p.match ?? "exact", reason: "placeholder" });
+  return row;
+}
+function notASchoolIn(rows) {
+  const regexes = new Map(rows.filter((row) => row.kind === "regex").map((row) => [row, new RegExp(row.pattern, "iu")]));
+  return (print) => {
+    const text = normalizeForRefusal(print);
+    if (text === "")
+      return;
+    const placeholder = placeholderOf(text);
+    if (placeholder !== undefined)
+      return placeholderRow(placeholder);
+    for (const row of rows) {
+      if (row.kind === "exact" && text === row.pattern)
+        return row;
+      if (row.kind === "prefix" && text.startsWith(row.pattern))
+        return row;
+      if (row.kind === "regex" && regexes.get(row)?.test(text))
+        return row;
+    }
+    return;
+  };
+}
+function exceptionsByLength(rows) {
+  return [...rows].sort((a, b) => b.phrase.length - a.phrase.length);
+}
+
+var SCHOOL_FLUFF_VOCABULARY = new Map([
+  [
+    "irish",
+    {
+      canonical: "irish",
+      kind: "word",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: true
+    }
+  ],
+  [
+    "dance",
+    {
+      canonical: "dance",
+      kind: "word",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: true
+    }
+  ],
+  [
+    "dancing",
+    {
+      canonical: "dancing",
+      kind: "word",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: true
+    }
+  ],
+  [
+    "dancers",
+    {
+      canonical: "dancers",
+      kind: "word",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: true
+    }
+  ],
+  [
+    "traditional",
+    {
+      canonical: "traditional",
+      kind: "word",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: true
+    }
+  ],
+  [
+    "the",
+    {
+      canonical: "the",
+      kind: "word",
+      lowerInside: true,
+      descriptor: true,
+      truncatable: false,
+      tokenFluff: true
+    }
+  ],
+  [
+    "of",
+    {
+      canonical: "of",
+      kind: "word",
+      lowerInside: true,
+      descriptor: true,
+      truncatable: false,
+      tokenFluff: true
+    }
+  ],
+  [
+    "and",
+    {
+      canonical: "and",
+      kind: "word",
+      lowerInside: true,
+      descriptor: true,
+      truncatable: false,
+      tokenFluff: true
+    }
+  ],
+  [
+    "na",
+    {
+      canonical: "na",
+      kind: "word",
+      lowerInside: true,
+      descriptor: false,
+      truncatable: false,
+      tokenFluff: true
+    }
+  ],
+  [
+    "an",
+    {
+      canonical: "an",
+      kind: "word",
+      lowerInside: true,
+      descriptor: false,
+      truncatable: false,
+      tokenFluff: true
+    }
+  ],
+  [
+    "a",
+    {
+      canonical: "a",
+      kind: "word",
+      lowerInside: true,
+      descriptor: false,
+      truncatable: false,
+      tokenFluff: false
+    }
+  ],
+  [
+    "do",
+    {
+      canonical: "do",
+      kind: "word",
+      lowerInside: true,
+      descriptor: false,
+      truncatable: false,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish dance",
+    {
+      canonical: "irish dance",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish dancing",
+    {
+      canonical: "irish dancing",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "of irish dance",
+    {
+      canonical: "of irish dance",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "of irish dancing",
+    {
+      canonical: "of irish dancing",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "school of irish dance",
+    {
+      canonical: "school of irish dance",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "school of irish dancing",
+    {
+      canonical: "school of irish dancing",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "school of dance",
+    {
+      canonical: "school of dance",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "school of dancing",
+    {
+      canonical: "school of dancing",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish dance school",
+    {
+      canonical: "irish dance school",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish dancing school",
+    {
+      canonical: "irish dancing school",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish dance academy",
+    {
+      canonical: "irish dance academy",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "dance academy",
+    {
+      canonical: "dance academy",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish step dance",
+    {
+      canonical: "irish step dance",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ],
+  [
+    "irish step dancing",
+    {
+      canonical: "irish step dancing",
+      kind: "phrase",
+      lowerInside: false,
+      descriptor: true,
+      truncatable: true,
+      tokenFluff: false
+    }
+  ]
+]);
+function schoolFluff(text) {
+  return SCHOOL_FLUFF_VOCABULARY.get(text.toLocaleLowerCase());
+}
+function isFluffWord(token) {
+  return schoolFluff(token)?.kind === "word";
+}
+function isTruncatedFluff(token) {
+  const t = token.toLocaleLowerCase();
+  if (t === "")
+    return false;
+  for (const entry of SCHOOL_FLUFF_VOCABULARY.values()) {
+    if (entry.kind !== "word" || !entry.truncatable)
+      continue;
+    if (entry.canonical.length > t.length && entry.canonical.startsWith(t))
+      return true;
+  }
+  return false;
+}
+var FLUFF_PHRASES = [...SCHOOL_FLUFF_VOCABULARY.values()].filter((entry) => entry.kind === "phrase").map((entry) => entry.canonical).sort((a, b) => b.length - a.length || a.localeCompare(b));
+function isFluffPhrasePrefix(text) {
+  const t = text.toLocaleLowerCase();
+  if (t === "")
+    return false;
+  return FLUFF_PHRASES.some((phrase) => phrase.startsWith(t));
+}
+function trailingFluffRun(tokens, distinctive) {
+  let start = tokens.length;
+  for (let i = tokens.length - 1;i >= 0; i -= 1) {
+    if (!isFluffPhrasePrefix(tokens.slice(i).join(" ")))
+      continue;
+    if (!tokens.slice(0, i).some(distinctive))
+      continue;
+    start = i;
+  }
+  while (start > 0) {
+    const token = tokens[start - 1] ?? "";
+    if (!isFluffWord(token) && !isTruncatedFluff(token) && distinctive(token))
+      break;
+    if (!tokens.slice(0, start - 1).some(distinctive))
+      break;
+    start -= 1;
+  }
+  return start;
+}
+
+import { nameParticle } from "@finbheara/names/particles";
+var FUSED_PREFIXES = new Set(["O", "Mc", "Mac"]);
+function joinedPrefix(printed, next) {
+  if (!/^\p{L}{2}/u.test(next))
+    return;
+  const particle = nameParticle(printed);
+  if (particle === undefined || !particle.standalone)
+    return;
+  if (!FUSED_PREFIXES.has(particle.canonical))
+    return;
+  return particle.join === "apostrophe" ? `${particle.canonical}'${next}` : `${particle.canonical}${next}`;
+}
+
+var SCHOOL_INSTITUTION_VOCABULARY = new Map([
+  [
+    "academy",
+    {
+      canonical: "academy",
+      label: "Academy",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: true
+    }
+  ],
+  [
+    "acadamy",
+    {
+      canonical: "academy",
+      label: "Academy",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "acadamh",
+    {
+      canonical: "academy",
+      label: "Academy",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "accademia",
+    {
+      canonical: "academy",
+      label: "Academy",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "school",
+    {
+      canonical: "school",
+      label: "School",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: true
+    }
+  ],
+  [
+    "schools",
+    {
+      canonical: "school",
+      label: "School",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "sd",
+    {
+      canonical: "school",
+      label: "School",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "ecole",
+    {
+      canonical: "school",
+      label: "School",
+      kind: "word",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "escuela",
+    {
+      canonical: "school",
+      label: "School",
+      kind: "word",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "scoil",
+    {
+      canonical: "scoilrince",
+      label: "S.R.",
+      kind: "word",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "scoil rince",
+    {
+      canonical: "scoilrince",
+      label: "S.R.",
+      kind: "phrase",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "s r",
+    {
+      canonical: "scoilrince",
+      label: "S.R.",
+      kind: "phrase",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "sr",
+    {
+      canonical: "scoilrince",
+      label: "S.R.",
+      kind: "word",
+      position: "prefix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "studio",
+    {
+      canonical: "studio",
+      label: "Studio",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: false
+    }
+  ],
+  [
+    "studios",
+    {
+      canonical: "studio",
+      label: "Studio",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "company",
+    {
+      canonical: "company",
+      label: "Company",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: false
+    }
+  ],
+  [
+    "institute",
+    {
+      canonical: "institute",
+      label: "Institute",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: false
+    }
+  ],
+  [
+    "center",
+    {
+      canonical: "center",
+      label: "Center",
+      kind: "word",
+      position: "suffix",
+      truncatable: true,
+      glued: false
+    }
+  ],
+  [
+    "centre",
+    {
+      canonical: "center",
+      label: "Center",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ],
+  [
+    "club",
+    {
+      canonical: "club",
+      label: "Club",
+      kind: "word",
+      position: "suffix",
+      truncatable: false,
+      glued: false
+    }
+  ]
+]);
+function foldText(text) {
+  return text.toLocaleLowerCase().normalize("NFD").replace(/\p{M}/gu, "").replace(/[^a-z0-9]+/g, " ").trim();
+}
+function schoolInstitution(text) {
+  return SCHOOL_INSTITUTION_VOCABULARY.get(foldText(text));
+}
+var LABEL_BY_TYPE = new Map([...SCHOOL_INSTITUTION_VOCABULARY.values()].map((v) => [v.canonical, v.label]));
+function institutionLabel(type) {
+  return LABEL_BY_TYPE.get(type);
+}
+var INSTITUTION_TYPES = [...LABEL_BY_TYPE.keys()].sort();
+var INSTITUTION_PHRASES = [...SCHOOL_INSTITUTION_VOCABULARY].filter(([, v]) => v.kind === "phrase").map(([k]) => k).sort();
+var GLUED_INSTITUTION_SUFFIXES = [...SCHOOL_INSTITUTION_VOCABULARY].filter(([, v]) => v.glued).map(([k]) => k).sort();
+function truncatedInstitution(tail) {
+  const folded = foldText(tail);
+  if (folded === "")
+    return;
+  let found;
+  for (const [key, entry] of SCHOOL_INSTITUTION_VOCABULARY) {
+    if (!entry.truncatable)
+      continue;
+    if (key.length <= folded.length || !key.startsWith(folded))
+      continue;
+    if (found !== undefined && found.canonical !== entry.canonical)
+      return;
+    found ??= entry;
+  }
+  return found;
+}
+
+var QUALIFIER_DELIMITER = /[,;:()[\]/–—-]/;
+var NEVER_PLACE = new Map([
+  ["de", "name particle: `De <Surname>`, and Spanish `de <Place>`"],
+  ["ni", "Irish patronymic particle: `Ní <Surname>`"],
+  ["mo", "Irish possessive: `Mo <Word>`"],
+  ["na", "Irish article: `Rince na <Word>`"],
+  ["in", "Irish preposition: `<Word> In <Word>`; and `Inc` truncated to `In`"],
+  ["co", "Company: `<Surname> & Co.`. Bracketed `(US-CO)` is still Colorado"],
+  ["id", "Irish Dance: `<Surname> School of ID`"],
+  ["sd", "School of Dance: `<Surname> SD`"]
+]);
+var NEVER_NAME = new Map([
+  ["de", "name particle: `De <Surname>`; and Spanish `de <Place>`"],
+  ["ni", "Irish patronymic particle: `Ní <Surname>`"],
+  ["ui", "Irish patronymic particle: `Uí <Surname>`"],
+  ["mo", "Irish possessive: `Mo <Word>`"],
+  ["na", "Irish article: `Rince na <Word>`"],
+  ["an", "Irish article: `<Word> an Rince`"],
+  ["in", "Irish preposition: `<Word> In <Word>`; and `Inc` truncated to `In`"],
+  ["co", "Company: `<Surname> & Co`"],
+  ["id", "Irish Dance: `ID de <Place>` keys the place, as `Irish Dancing de <Place>` does"],
+  ["sd", "School of Dance: `<Surname> SD`"],
+  ["da", "`Dance` truncated: `<Name> Academy of Irish Da` keys the name"]
+]);
+var GENERIC_TLD = "com|net|org|edu|gov|mil|int|info|biz";
+var WEB_SPAN = new RegExp([
+  "[A-Za-z][A-Za-z0-9+.-]*://\\S+",
+  "(?:^|[\\s([])www\\.\\S+",
+  "[^\\s@]+@[^\\s@]+\\.[A-Za-z]{2,}",
+  `(?<![A-Za-z0-9.@-])(?:[A-Za-z0-9][A-Za-z0-9-]*\\.)*[A-Za-z0-9][A-Za-z0-9-]+\\.(?:${GENERIC_TLD})(?![A-Za-z0-9-])`
+].join("|"), "giu");
+function printZones(raw) {
+  const qualifier = new Set;
+  const bracketed = new Set;
+  const qualifierAny = new Set;
+  const runs = [...raw.matchAll(/[A-Za-z0-9]+/g)];
+  const web = [];
+  for (const m of raw.matchAll(WEB_SPAN))
+    web.push([m.index ?? 0, (m.index ?? 0) + m[0].length]);
+  const inside = new Set;
+  const outside = new Set;
+  const trailing = new Set;
+  for (let i = runs.length - 1;i > 0; i--) {
+    const here = runs[i];
+    const prev = runs[i - 1];
+    if (here === undefined || prev === undefined)
+      break;
+    const gap = raw.slice((prev.index ?? 0) + prev[0].length, here.index ?? 0);
+    if (!QUALIFIER_DELIMITER.test(gap))
+      break;
+    if (i - 1 === 0)
+      break;
+    trailing.add(i - 1);
+  }
+  let depth = 0;
+  let cursor = 0;
+  for (let i = 0;i < runs.length; i++) {
+    const run = runs[i];
+    const text = run?.[0];
+    if (run === undefined || text === undefined)
+      continue;
+    const at = run.index ?? cursor;
+    for (const ch of raw.slice(cursor, at)) {
+      if (ch === "(" || ch === "[")
+        depth++;
+      else if ((ch === ")" || ch === "]") && depth > 0)
+        depth--;
+    }
+    cursor = at + text.length;
+    const folded = text.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "");
+    (web.some(([s, e]) => at >= s && at < e) ? inside : outside).add(folded);
+    const before = raw.slice(0, at).trimEnd().slice(-1);
+    const after = raw.slice(cursor).trimStart().slice(0, 1);
+    const atQualifier = i === runs.length - 1 || before !== "" && QUALIFIER_DELIMITER.test(before) || after !== "" && QUALIFIER_DELIMITER.test(after) && trailing.has(i);
+    if (atQualifier)
+      qualifierAny.add(folded);
+    if (folded.length > 2)
+      continue;
+    if (atQualifier)
+      qualifier.add(folded);
+    if (depth > 0)
+      bracketed.add(folded);
+  }
+  const webOnly = new Set([...inside].filter((f) => !outside.has(f)));
+  return { qualifier, bracketed, qualifierAny, web, webOnly, tailCode: tailCode(raw, runs) };
+}
+var GOVERNS_THE_NEXT_WORD = new Set(["de", "mo"]);
+function tailCode(raw, runs) {
+  const last = runs[runs.length - 1];
+  const prev = runs[runs.length - 2];
+  if (last === undefined || prev === undefined)
+    return null;
+  const text = last[0];
+  if (text.length > 2 || text !== text.toUpperCase() || !/^[A-Z]+$/.test(text))
+    return null;
+  const at = last.index ?? 0;
+  const folded = text.toLowerCase();
+  const gap = raw.slice((prev.index ?? 0) + prev[0].length, at);
+  const marked = /[,;:/\\\u2013\u2014]/u.test(gap) || /\s-|-\s/u.test(gap);
+  const bare = GOVERNS_THE_NEXT_WORD.has(folded) && /^\s+$/u.test(gap) && /\p{Ll}/u.test(raw);
+  if (!marked && !bare)
+    return null;
+  const only = runs.filter((r) => r[0].toLowerCase() === folded).length === 1;
+  return { folded, at, only };
+}
+function opensLocation(folded, at, index) {
+  if (index === undefined ? at.webOnly.has(folded) : inWebSpan(at, index))
+    return false;
+  if (folded.length > 2)
+    return true;
+  if (NEVER_PLACE.has(folded))
+    return at.bracketed.has(folded) || isTailCode(folded, at, index);
+  return at.qualifier.has(folded);
+}
+function isTailCode(folded, at, index) {
+  const tail = at.tailCode;
+  if (tail === null || tail.folded !== folded)
+    return false;
+  return index === undefined ? tail.only : index === tail.at;
+}
+function inWebSpan(at, index) {
+  return at.web.some(([start, end]) => index >= start && index < end);
+}
+
+var SCHOOL_FLUFF_WORDS = new Set([
+  "academy",
+  "irish",
+  "dance",
+  "dancing",
+  "dancers",
+  "school",
+  "company",
+  "traditional",
+  "the",
+  "of",
+  "and",
+  "studio",
+  "center",
+  "centre",
+  "institute",
+  "scoil",
+  "rince",
+  "na",
+  "an"
+]);
+var SCHOOL_GENERIC_NAME_PARTS = new Set(["celtic", "clann"]);
+function hasSpecificToken(tokens) {
+  for (const t of tokens)
+    if (!SCHOOL_GENERIC_NAME_PARTS.has(t))
+      return true;
+  return false;
+}
+var GLUED_FLUFF_SUFFIXES = ["academy", "school"];
+function deglueToken(token) {
+  let t = token;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const suf of GLUED_FLUFF_SUFFIXES) {
+      if (t.length > suf.length + 2 && t.endsWith(suf)) {
+        t = t.slice(0, -suf.length);
+        changed = true;
+      }
+    }
+  }
+  return t;
+}
+function isTruncatedFluff2(token) {
+  for (const w of SCHOOL_FLUFF_WORDS) {
+    if (w.length > token.length && w.startsWith(token))
+      return true;
+  }
+  return false;
+}
+function isDiscardedAnyway(token) {
+  return token.length <= 2 || SCHOOL_FLUFF_WORDS.has(token);
+}
+function distinctiveTokens(tokens) {
+  return tokens.filter((t) => t.length > 2 && !SCHOOL_FLUFF_WORDS.has(t));
+}
+var APOSTROPHE_VARIANTS = /['`´‘’“”’]/g;
+function foldSchoolName(raw) {
+  let s = raw.toLowerCase();
+  s = s.normalize("NFD").replace(/[̀-ͯ]/g, "");
+  s = s.replace(/ß/g, "ss").replace(/æ/g, "ae").replace(/œ/g, "oe").replace(/ø/g, "o");
+  s = s.replace(APOSTROPHE_VARIANTS, "'");
+  s = s.replace(/'/g, "");
+  const words = [];
+  for (const word of s.split(/[^a-z0-9]+/)) {
+    if (word === "")
+      continue;
+    const prev = words[words.length - 1];
+    const joined = prev === undefined ? undefined : joinedPrefix(prev, word);
+    if (joined === undefined)
+      words.push(word);
+    else
+      words[words.length - 1] = joined.toLowerCase().replace(/'/g, "");
+  }
+  return words.join(" ");
+}
+function schoolKeyTokens(raw) {
+  const folded = foldSchoolName(raw).split(" ").filter((t) => t !== "").map(deglueToken);
+  let end = folded.length;
+  while (end > 0) {
+    const last = folded[end - 1];
+    if (!isTruncatedFluff2(last) && !isDiscardedAnyway(last))
+      break;
+    if (!hasSpecificToken(distinctiveTokens(folded.slice(0, end - 1))))
+      break;
+    end -= 1;
+  }
+  return [...new Set(distinctiveTokens(folded.slice(0, end)))];
+}
+
+var SCHOOL_REFUSED = "!!!NOTASCHOOL";
+var TITLE_CASE_STATE_CODES = new Set(["Nsw", "Qld", "Vic", "Tas"]);
+function schoolInitials(name) {
+  return INITIALS.get(name) ?? { declared: null, derived: [] };
+}
+var TRAILING_BRACKET = /\s*[([]([^()[\]]*)[)\]]\s*$/;
+var DANGLING_MARK = /[\s,;:/\\\-–—([]+$/;
+function schoolPrintSplit(print, reader) {
+  const schoolName = (p) => reader.schoolName(p);
+  let parsed = schoolName(print);
+  let annotation = null;
+  if (!LOCATION_AT.has(parsed)) {
+    const bracket = TRAILING_BRACKET.exec(parsed.sn1);
+    const inside = bracket?.[1]?.trim() ?? "";
+    if (bracket !== null && inside !== "") {
+      annotation = inside;
+      parsed = schoolName(parsed.sn1.slice(0, bracket.index));
+    }
+  }
+  const at = LOCATION_AT.get(parsed);
+  const sn1 = parsed.sn1;
+  if (at === undefined)
+    return { name: sn1.trim(), qualifier: null, location: null, annotation };
+  return {
+    name: sn1.slice(0, at).replace(DANGLING_MARK, "").trim(),
+    qualifier: sn1.slice(at).replace(/[\s)\]]+$/, "").trim(),
+    location: parsed.location,
+    annotation
+  };
+}
+var PART_KEYS = new WeakMap;
+var INITIALS = new WeakMap;
+var LOCATION_AT = new WeakMap;
+function realWords(name) {
+  const hit = REAL_WORDS.get(name);
+  if (hit !== undefined)
+    return hit;
+  const words = Object.freeze([...new Set(PART_KEYS.get(name) ?? [])].sort());
+  REAL_WORDS.set(name, words);
+  return words;
+}
+function realWordsInPrintOrder(name) {
+  return Object.freeze([...new Set(PART_KEYS.get(name) ?? [])]);
+}
+var REAL_WORDS = new WeakMap;
+var DEFAULT_SCHOOL_NAME_CAPACITY = 16384;
+function createSchoolNameReader(options = {}) {
+  const lexicon = options.lexicon;
+  const EXCEPTIONS_BY_LENGTH = exceptionsByLength(options.exceptions ?? SCHOOL_NAME_EXCEPTIONS);
+  const notASchool = notASchoolIn([
+    ...options.garbage ?? [],
+    ...options.refusals ?? NOT_A_SCHOOL
+  ]);
+  const CP1252_HIGH = "€‚ƒ„…†‡ˆ‰Š‹Œ" + "Ž‘’“”•–—˜™š›" + "œžŸ";
+  const BYTE_OF_CP1252 = new Map([...CP1252_HIGH].map((ch, i) => [ch.codePointAt(0), 128 + i]));
+  const MOJIBAKE = /[Â-ßà-ï][€-¿‚-›ŒŠŽ]/u;
+  function undoMojibake(s) {
+    const bytes = new Uint8Array(s.length);
+    for (let i = 0;i < s.length; i++) {
+      const code = s.charCodeAt(i);
+      const byte = BYTE_OF_CP1252.get(code) ?? code;
+      if (byte > 255)
+        return;
+      bytes[i] = byte;
+    }
+    try {
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    } catch {
+      return;
+    }
+  }
+  function repairMojibake(print) {
+    let s = print;
+    for (let round = 0;round < 3 && MOJIBAKE.test(s); round++) {
+      const undone = undoMojibake(s);
+      if (undone === undefined || undone === s)
+        return s;
+      s = undone;
+    }
+    return s;
+  }
+  function renderSn1(print) {
+    return normalizeApostrophes(repairMojibake(print).normalize("NFKC")).replace(/\p{Cf}+/gu, "").replace(/\p{Cc}+/gu, " ").replace(/\s+/gu, " ").trim();
+  }
+  const COMPOUND_OPENERS = new Set([
+    "hyphen",
+    "slash",
+    "backslash",
+    "comma"
+  ]);
+  function separatorOf(gap) {
+    if (gap.includes("-"))
+      return "hyphen";
+    if (gap.includes("/"))
+      return "slash";
+    if (gap.includes("\\"))
+      return "backslash";
+    if (gap.includes(","))
+      return "comma";
+    if (/^\s+$/u.test(gap))
+      return "space";
+    return "other";
+  }
+  function printedWords(sn1) {
+    const out = [];
+    let cursor = 0;
+    for (const match of sn1.matchAll(/[\p{L}\p{N}']+/gu)) {
+      const at = match.index ?? cursor;
+      const gap = sn1.slice(cursor, at);
+      cursor = at + match[0].length;
+      const text = match[0].replace(/^'+|'+$/gu, "");
+      if (text === "")
+        continue;
+      const prev = out[out.length - 1];
+      const joined = prev === undefined ? undefined : joinedPrefix(prev.printed, text);
+      if (prev !== undefined && joined !== undefined) {
+        prev.printed = joined;
+        continue;
+      }
+      out.push({ printed: text, sep: out.length === 0 ? "start" : separatorOf(gap), at });
+    }
+    return out;
+  }
+  function collapse(tokens, at, len, token) {
+    const words = tokens.slice(at, at + len).flatMap((t) => t.words);
+    tokens.splice(at, len, { ...token, words });
+  }
+  function runAt(tokens, words) {
+    outer:
+      for (let i = 0;i + words.length <= tokens.length; i++) {
+        for (let j = 0;j < words.length; j++) {
+          const t = tokens[i + j];
+          if (t === undefined || t.cls !== null || t.text !== words[j])
+            continue outer;
+        }
+        return i;
+      }
+    return -1;
+  }
+  function applyPhraseExceptions(tokens) {
+    for (;; ) {
+      let hit;
+      let at = -1;
+      for (const ex of EXCEPTIONS_BY_LENGTH) {
+        if (ex.scope !== "phrase")
+          continue;
+        at = runAt(tokens, ex.phrase.split(" "));
+        if (at >= 0) {
+          hit = ex;
+          break;
+        }
+      }
+      if (hit === undefined || at < 0)
+        return;
+      collapse(tokens, at, hit.phrase.split(" ").length, {
+        text: hit.token,
+        cls: hit.as === "NAME_PART" ? "NAME_PART" : "FLUFF",
+        exception: hit.phrase
+      });
+    }
+  }
+  function deglueInstitutions(tokens) {
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === undefined || token.cls !== null)
+        continue;
+      const suffix = GLUED_INSTITUTION_SUFFIXES.find((s) => token.text.length > s.length + 2 && token.text.endsWith(s));
+      if (suffix === undefined)
+        continue;
+      const word = token.words[0];
+      if (token.words.length !== 1 || word.printed.length <= suffix.length)
+        continue;
+      tokens.splice(i, 1, {
+        text: token.text.slice(0, -suffix.length),
+        words: [{ printed: word.printed.slice(0, -suffix.length), sep: word.sep, at: word.at }],
+        cls: null
+      }, {
+        text: suffix,
+        words: [
+          {
+            printed: word.printed.slice(-suffix.length),
+            sep: "other",
+            at: word.at + word.printed.length - suffix.length
+          }
+        ],
+        cls: null
+      });
+      i--;
+    }
+  }
+  function applyInstitutionPhrases(tokens) {
+    for (const phrase of INSTITUTION_PHRASES) {
+      const words = phrase.split(" ");
+      for (;; ) {
+        const at = runAt(tokens, words);
+        if (at < 0)
+          break;
+        const entry = schoolInstitution(phrase);
+        if (entry === undefined)
+          break;
+        collapse(tokens, at, words.length, {
+          text: phrase,
+          cls: "INSTITUTION_TYPE",
+          institution: entry.canonical
+        });
+      }
+    }
+  }
+  function applyPlaces(tokens, at, sn1) {
+    for (let i = 1;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token.cls !== null)
+        continue;
+      if (!opensLocation(token.text, at, token.words[0]?.at))
+        continue;
+      const tail = tokens.slice(i);
+      if (tail.some((t) => t.cls !== null))
+        continue;
+      const words = tail.map((t) => t.words.map((w) => w.printed).join(" "));
+      const gate = codeOutOfCase(tokens, i, sn1);
+      let printed = tail.flatMap((t) => t.words.map((w) => w.printed)).join(" ");
+      if (!commaTailStateCode(tail) && !areAllPlaceTokens2(words, 0, gate)) {
+        const marked = punctuatedTail(sn1, tail);
+        if (marked === null || !areAllPlaceTokens2([marked], 0, gate))
+          continue;
+        printed = marked;
+      }
+      if (surnameBeatsAWholeWord(sn1, tail))
+        continue;
+      const read = place2(printed, { declared: true });
+      if (read.refusal !== null || read.nodes.length === 0)
+        continue;
+      if (surnameBeatsAWholeWord(sn1, tail, read))
+        continue;
+      if (bareCountryCode(token, read))
+        continue;
+      if (read.truncated && nameBeatsACut(printed))
+        continue;
+      if (read.truncated && !survivesWithout(tokens, i, tail.length))
+        continue;
+      for (const t of tail) {
+        t.cls = "LOCATION_HINT";
+        if (read.pl3 !== "")
+          t.place = read.pl3;
+      }
+      return { read, at: token.words[0]?.at ?? 0 };
+    }
+    return null;
+  }
+  function punctuatedTail(sn1, tail) {
+    const first = tail[0]?.words[0];
+    const lastToken = tail[tail.length - 1];
+    const last = lastToken?.words[lastToken.words.length - 1];
+    if (first === undefined || last === undefined)
+      return null;
+    const raw = sn1.slice(first.at, last.at + last.printed.length);
+    if (!/[,/;]/.test(raw) || /[()[\]]/.test(raw))
+      return null;
+    return raw;
+  }
+  function codeOutOfCase(tokens, i, sn1) {
+    const opener = tokens[i]?.words[0]?.at;
+    if (opener !== undefined && bracketed(sn1, opener))
+      return true;
+    const before = tokens[tokens.length - 2];
+    if (before === undefined)
+      return false;
+    if (schoolInstitution(before.text) !== undefined)
+      return true;
+    return isPlaceToken2(before.words.map((w) => w.printed).join(" "));
+  }
+  function bracketed(sn1, index) {
+    let start = index;
+    while (start > 0 && !/[\p{L}\p{N}']/u.test(sn1[start - 1]))
+      start--;
+    return /[([]/u.test(sn1.slice(start, index));
+  }
+  function commaTailStateCode(tail) {
+    if (tail.length !== 1)
+      return false;
+    const token = tail[0];
+    if (token.words.length !== 1)
+      return false;
+    const word = token.words[0];
+    return word.sep === "comma" && TITLE_CASE_STATE_CODES.has(word.printed);
+  }
+  function bareCountryCode(token, read) {
+    if (token.words.length !== 1)
+      return false;
+    const word = token.words[0];
+    if (word.sep !== "space")
+      return false;
+    if (word.printed === word.printed.toLocaleUpperCase())
+      return false;
+    const country = countryCodeOf2(word.printed);
+    return country !== undefined && read.nodes.some((n) => n.id === country);
+  }
+  function nameBeatsACut(printed) {
+    if (/\s/.test(printed.trim()))
+      return false;
+    const flags = flagsOf(printed);
+    if (flags === null)
+      return false;
+    return flags.surname || flags.ambiguous || flags.tradename || flags.given;
+  }
+  function surnameBeatsAWholeWord(sn1, tail, read) {
+    if (tail.length !== 1)
+      return false;
+    const token = tail[0];
+    if (token.words.length !== 1)
+      return false;
+    const word = token.words[0];
+    if (word.sep !== "space" && word.sep !== "hyphen")
+      return false;
+    if (declaredQualifier(sn1, word.at))
+      return false;
+    const flags = flagsOf(word.printed);
+    if (flags === null)
+      return false;
+    if (!(flags.surname || flags.ambiguous))
+      return false;
+    return !flags.place || read !== undefined && namesOnlyACountry(read);
+  }
+  function namesOnlyACountry(read) {
+    return read.nodes.some((n) => n.kind === "country") && !read.nodes.some((n) => n.kind === "subdivision" || n.kind === "city");
+  }
+  function applyLexiconPlaces(tokens, at, sn1) {
+    if (lexicon === undefined)
+      return false;
+    let last = tokens.length - 1;
+    while (last >= 0 && tokens[last]?.cls === "LOCATION_HINT")
+      last--;
+    if (last <= 0)
+      return false;
+    const token = tokens[last];
+    if (token.cls !== null)
+      return false;
+    if (!at.qualifierAny.has(token.text))
+      return false;
+    if (!declaredQualifier(sn1, token.words[0]?.at))
+      return false;
+    if (schoolInstitution(token.text) !== undefined)
+      return false;
+    if (truncatedInstitution(token.text) !== undefined)
+      return false;
+    if (isFluffWord(token.text))
+      return false;
+    const flags = flagsOf(token.words.map((w) => w.printed).join(" "));
+    if (flags === null || !flags.place)
+      return false;
+    if (flags.surname || flags.ambiguous || flags.tradename || flags.given)
+      return false;
+    if (!survivesWithout(tokens, last))
+      return false;
+    token.cls = "LOCATION_HINT";
+    return true;
+  }
+  function declaredQualifier(sn1, index) {
+    if (index === undefined || index <= 0)
+      return false;
+    let start = index;
+    while (start > 0 && !/[\p{L}\p{N}']/u.test(sn1[start - 1]))
+      start--;
+    const gap = sn1.slice(start, index);
+    if (/[,;:/\\([\u2013\u2014]/u.test(gap))
+      return true;
+    return /\s-|-\s/u.test(gap);
+  }
+  function distinctive(text) {
+    if (text.length <= 2)
+      return false;
+    if (schoolInstitution(text) !== undefined)
+      return false;
+    if (truncatedInstitution(text) !== undefined)
+      return false;
+    return !isFluffWord(text);
+  }
+  function survivesWithout(tokens, at, width = 1) {
+    const off = (i) => i >= at && i < at + width;
+    if (tokens.some((t, i) => !off(i) && (t.cls === "NAME_PART" || t.cls === null && distinctive(t.text))))
+      return true;
+    const core = tokens.filter((t, i) => !off(i) && t.cls === null).map((t) => t.text).join(" ");
+    if (core === "")
+      return false;
+    return EXCEPTIONS_BY_LENGTH.some((ex) => ex.scope === "label" && ex.phrase === core);
+  }
+  function applyLabelExceptions(tokens) {
+    if (tokens.some((t) => t.cls === "NAME_PART"))
+      return;
+    const core = tokens.filter((t) => t.cls === null).map((t) => t.text).join(" ");
+    for (const ex of EXCEPTIONS_BY_LENGTH) {
+      if (ex.scope !== "label" || core !== ex.phrase)
+        continue;
+      const first = tokens.findIndex((t) => t.cls === null);
+      const words = tokens.filter((t) => t.cls === null).flatMap((t) => t.words);
+      if (first < 0 || words.length === 0)
+        return;
+      for (let i = tokens.length - 1;i >= 0; i--)
+        if (tokens[i]?.cls === null)
+          tokens.splice(i, 1);
+      tokens.splice(first, 0, {
+        text: ex.token,
+        words,
+        cls: ex.as === "NAME_PART" ? "NAME_PART" : "FLUFF",
+        exception: ex.phrase
+      });
+      return;
+    }
+  }
+  function classifyWords(tokens) {
+    for (const token of tokens) {
+      if (token.cls !== null)
+        continue;
+      const inst = schoolInstitution(token.text);
+      if (inst !== undefined) {
+        token.cls = "INSTITUTION_TYPE";
+        token.institution = inst.canonical;
+        continue;
+      }
+      if (isFluffWord(token.text)) {
+        token.cls = "FLUFF";
+        continue;
+      }
+      if (token.text.length <= 2) {
+        token.cls = "FLUFF";
+        token.short = true;
+        continue;
+      }
+      token.cls = "NAME_PART";
+    }
+  }
+  function guardPrefixInstitutions(tokens) {
+    for (let i = 0;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === undefined || token.cls !== "INSTITUTION_TYPE")
+        continue;
+      if (schoolInstitution(token.text)?.position !== "prefix")
+        continue;
+      if (tokens.slice(i + 1).some((t) => t.cls === "NAME_PART"))
+        continue;
+      token.institution = undefined;
+      if (isFluffWord(token.text))
+        token.cls = "FLUFF";
+      else if (token.text.length <= 2) {
+        token.cls = "FLUFF";
+        token.short = true;
+      } else
+        token.cls = "NAME_PART";
+    }
+  }
+  function eatTruncatedTail(tokens) {
+    let ate = false;
+    const names = new Set(tokens.filter((t) => t.cls === "NAME_PART").map((t) => t.text));
+    const start = trailingFluffRun(tokens.map((t) => t.text), (text) => names.has(text));
+    for (let i = start;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === undefined || token.cls !== "NAME_PART")
+        continue;
+      const entry = truncatedInstitution(token.text);
+      if (entry !== undefined) {
+        token.cls = "INSTITUTION_TYPE";
+        token.institution = entry.canonical;
+      } else
+        token.cls = "FLUFF";
+      token.truncated = true;
+      ate = true;
+    }
+    for (let end = tokens.length;end > 0; end--) {
+      const token = tokens[end - 1];
+      if (token === undefined)
+        break;
+      if (token.cls === "FLUFF")
+        continue;
+      if (token.cls !== "NAME_PART")
+        break;
+      const entry = truncatedInstitution(token.text);
+      if (entry === undefined)
+        break;
+      if (!tokens.slice(0, end - 1).some((t) => t.cls === "NAME_PART"))
+        break;
+      token.cls = "INSTITUTION_TYPE";
+      token.institution = entry.canonical;
+      token.truncated = true;
+      ate = true;
+    }
+    return ate;
+  }
+  const CONNECTORS = new Set(["of", "and", "the", "na", "an", "a", "do", "de", "du", "la", "le"]);
+  function initialsOfWords(words) {
+    const folded = words.map((w) => foldSchoolName(w.printed)).filter((w) => /^[a-z]/.test(w));
+    const all = folded.map((w) => w[0]).join("");
+    const named = folded.filter((w) => !CONNECTORS.has(w)).map((w) => w[0]).join("");
+    return [...new Set([all, named])].filter((i) => i.length >= 3).map((i) => i.toUpperCase());
+  }
+  function applyDeclaredInitialism(tokens) {
+    for (let i = 1;i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === undefined || token.cls !== "NAME_PART" || token.exception !== undefined)
+        continue;
+      if (!/^[a-z]{3,8}$/.test(token.text))
+        continue;
+      const before = tokens.slice(0, i);
+      if (!before.some((t) => t.cls === "NAME_PART"))
+        continue;
+      const spelled = initialsOfWords(before.flatMap((t) => t.words));
+      if (!spelled.includes(token.text.toUpperCase()))
+        continue;
+      token.cls = "FLUFF";
+      return token.text.toUpperCase();
+    }
+    return null;
+  }
+  function initialsOf(tokens, declared) {
+    const words = tokens.filter((t) => t.cls !== "LOCATION_HINT" && t.text.toUpperCase() !== declared).flatMap((t) => t.words);
+    return Object.freeze({ declared, derived: Object.freeze(initialsOfWords(words)) });
+  }
+  function promote(tokens) {
+    if (tokens.some((t) => t.cls === "NAME_PART"))
+      return false;
+    const isInitials = (t) => t.short === true && !NEVER_NAME.has(t.text);
+    const initials = tokens.some(isInitials);
+    let promoted = false;
+    for (const token of tokens) {
+      if (initials ? !isInitials(token) : token.cls !== "LOCATION_HINT")
+        continue;
+      token.cls = "NAME_PART";
+      token.promoted = true;
+      promoted = true;
+    }
+    return promoted;
+  }
+  function joinerOf(sep) {
+    switch (sep) {
+      case "hyphen":
+        return "-";
+      case "slash":
+        return "/";
+      case "backslash":
+        return "\\";
+      case "comma":
+        return ", ";
+      default:
+        return " ";
+    }
+  }
+  function flagsOf(printed) {
+    if (lexicon === undefined)
+      return null;
+    const key = lexiconKey(printed);
+    return key === "" ? null : lexicon(key) ?? null;
+  }
+  const EXCEPTION_PHRASE = new Map([...EXCEPTIONS_BY_LENGTH].map((ex) => [ex.token, ex.phrase]));
+  function solidKey(word) {
+    return word.replace(/[^a-z0-9]+/g, "").toLocaleUpperCase();
+  }
+  function tokenKey(token) {
+    const phrase = token.exception === undefined ? undefined : EXCEPTION_PHRASE.get(token.text);
+    if (phrase === undefined)
+      return solidKey(token.text);
+    return phrase.split(" ").map(solidKey).filter((w) => w !== "").join(" ");
+  }
+  function partsOf(tokens) {
+    const out = [];
+    let run = [];
+    const printedOf = (t) => t.words.map((w) => w.printed).join(" ");
+    const flush = () => {
+      if (run.length === 0)
+        return;
+      const members = run;
+      run = [];
+      if (members.length === 1) {
+        const only = members[0];
+        const base = printedOf(only);
+        out.push({
+          part: { base, parts: [], lexicon: flagsOf(base) },
+          key: tokenKey(only),
+          members: [tokenKey(only)],
+          tokens: members
+        });
+        return;
+      }
+      const base = members.map((t, i) => i === 0 ? printedOf(t) : joinerOf(t.words[0].sep) + printedOf(t)).join("");
+      out.push({
+        part: {
+          base,
+          parts: members.map((t) => ({
+            base: printedOf(t),
+            parts: [],
+            lexicon: flagsOf(printedOf(t))
+          })),
+          lexicon: flagsOf(base)
+        },
+        key: members.map(tokenKey).join(" "),
+        members: members.map(tokenKey),
+        tokens: members
+      });
+    };
+    for (const token of tokens) {
+      if (token.cls !== "NAME_PART") {
+        flush();
+        continue;
+      }
+      if (run.length > 0 && !COMPOUND_OPENERS.has(token.words[0].sep))
+        flush();
+      run.push(token);
+    }
+    flush();
+    return out;
+  }
+  function locationKey(read) {
+    if (read === null)
+      return "";
+    if (read.pl3 !== "")
+      return read.pl3;
+    if (!read.isAmbiguous())
+      return "";
+    const ids = read.arm === "ambiguous" ? read.candidates.map((c) => c.pl3).filter((id) => id !== "") : [];
+    if (ids.length === 0)
+      return "";
+    return `${[...ids].sort().join("|")}?`;
+  }
+  function renderKey(keys, institution, read, ordered) {
+    if (keys.length === 0)
+      return "";
+    const core = (ordered ? [...keys] : [...keys].sort()).join(" ");
+    const type = institution === null ? "" : ` ${institution.toLocaleUpperCase()}`;
+    const at = locationKey(read);
+    return `${core}${type}${at === "" ? "" : ` (${at})`}`;
+  }
+  function nameWord(printed, first) {
+    const folded = foldSchoolName(printed);
+    if (!first && schoolFluff(folded)?.lowerInside === true && printed !== printed.toLocaleUpperCase())
+      return printed.toLocaleLowerCase();
+    return titleCaseNamePart(printed);
+  }
+  function renderException(token, first) {
+    const printed = token.words.map((w) => w.printed).join(" ");
+    const canonical = EXCEPTION_PHRASE.get(token.text);
+    const text = canonical !== undefined && foldSchoolName(printed) !== canonical ? canonical : printed;
+    return text.split(" ").map((w, i) => nameWord(w, first && i === 0)).join(" ");
+  }
+  function renderPart(part, first) {
+    const only = part.tokens[0];
+    if (part.tokens.length === 1 && only !== undefined && only.exception !== undefined)
+      return renderException(only, first);
+    const members = part.part.parts.length === 0 ? [part.part.base] : part.tokens.map((t) => ({ key: tokenKey(t), printed: t.words.map((w) => w.printed).join(" ") })).sort((a, b) => a.key < b.key ? -1 : 1).map((m) => m.printed);
+    return members.map((m, i) => m.split(" ").map((w, j) => nameWord(w, first && i === 0 && j === 0)).join(" ")).join(" ");
+  }
+  function renderSn2(tokens, parts, institution, read) {
+    const at = tokens.map((t) => t.cls);
+    const last = at.lastIndexOf("NAME_PART");
+    let first = at.indexOf("NAME_PART");
+    const joins = (t) => t?.cls === "FLUFF" && t.truncated !== true && schoolFluff(t.text)?.descriptor !== true;
+    while (first > 0 && joins(tokens[first - 1]))
+      first--;
+    const pieces = [];
+    let partAt = 0;
+    let started = false;
+    for (let i = first;i <= last && first >= 0; i++) {
+      const token = tokens[i];
+      if (token === undefined)
+        continue;
+      if (token.cls === "NAME_PART") {
+        const inRun = tokens[i - 1]?.cls === "NAME_PART" && COMPOUND_OPENERS.has(token.words[0].sep);
+        if (inRun)
+          continue;
+        const part = parts[partAt];
+        partAt++;
+        if (part !== undefined) {
+          pieces.push(renderPart(part, !started));
+          started = true;
+        }
+        continue;
+      }
+      if (joins(token))
+        pieces.push(token.words.map((w) => nameWord(w.printed, !started)).join(" "));
+    }
+    const core = pieces.join(" ");
+    const shown = read === null ? "" : read.pl2;
+    const tail = shown === "" ? "" : ` (${shown})`;
+    if (institution === null)
+      return `${core}${tail}`;
+    if (institution === "scoilrince")
+      return `${institutionLabel("scoilrince")} ${core}${tail}`.trim();
+    return `${core === "" ? "" : `${core} `}${institutionLabel(institution)}${tail}`;
+  }
+  function materialize(b) {
+    const out = {
+      get [Symbol.toStringTag]() {
+        return "SchoolName";
+      },
+      toString: () => b.sn2,
+      sn0: b.sn0,
+      sn1: b.sn1,
+      sn2: b.sn2,
+      sn3: b.sn3,
+      sn4: b.sn4,
+      parts: b.parts,
+      institution: b.institution,
+      location: b.location,
+      refusal: b.refusal,
+      isEmpty: () => b.empty,
+      isSchool: () => !b.empty && b.refusal === null,
+      surnames: () => b.surnames,
+      concerns: b.concerns
+    };
+    PART_KEYS.set(out, b.keys);
+    if (b.initials !== undefined)
+      INITIALS.set(out, b.initials);
+    if (b.locationAt !== undefined)
+      LOCATION_AT.set(out, b.locationAt);
+    return out;
+  }
+  const EMPTY = {
+    sn2: "",
+    sn3: "",
+    sn4: "",
+    parts: [],
+    keys: [],
+    institution: null,
+    location: null,
+    refusal: null,
+    empty: true,
+    surnames: [],
+    concerns: []
+  };
+  function surnamesOf(parts) {
+    const out = new Set;
+    const visit = (part) => {
+      if (part.parts.length > 0) {
+        for (const child of part.parts)
+          visit(child);
+        return;
+      }
+      const flags = part.lexicon;
+      if (flags === null || !flags.surname && !flags.ambiguous)
+        return;
+      const key = personName(`${part.base}${SURNAME_SEPARATOR}`).surnameKey();
+      if (key !== "")
+        out.add(key);
+    };
+    for (const part of parts)
+      visit(part);
+    return [...out].sort();
+  }
+  function build(print) {
+    const sn1 = renderSn1(print);
+    if (!/[\p{L}\p{N}]/u.test(sn1))
+      return materialize({ ...EMPTY, sn0: print, sn1 });
+    const row = notASchool(sn1);
+    if (row !== undefined) {
+      return materialize({
+        ...EMPTY,
+        sn0: print,
+        sn1,
+        sn2: SCHOOL_REFUSED,
+        sn3: SCHOOL_REFUSED,
+        sn4: SCHOOL_REFUSED,
+        empty: false,
+        refusal: { reason: row.reason, printed: print, row, value: SCHOOL_REFUSED }
+      });
+    }
+    const tokens = [];
+    for (const word of printedWords(sn1)) {
+      const text = foldSchoolName(word.printed);
+      if (text === "")
+        continue;
+      tokens.push({ text, words: [word], cls: null });
+    }
+    if (tokens.length === 0)
+      return materialize({ ...EMPTY, sn0: print, sn1 });
+    deglueInstitutions(tokens);
+    applyPhraseExceptions(tokens);
+    applyInstitutionPhrases(tokens);
+    const positions = printZones(sn1);
+    const tail = applyPlaces(tokens, positions, sn1);
+    const read = tail?.read ?? null;
+    const cutPlace = read?.truncated === true;
+    const lexiconPlace = applyLexiconPlaces(tokens, positions, sn1);
+    applyLabelExceptions(tokens);
+    classifyWords(tokens);
+    guardPrefixInstitutions(tokens);
+    const declared = applyDeclaredInitialism(tokens);
+    const truncated = eatTruncatedTail(tokens);
+    const promoted = promote(tokens);
+    const built = partsOf(tokens);
+    const parts = built.map((p) => p.part);
+    const keys = built.map((p) => p.key);
+    const members = built.flatMap((p) => p.members);
+    const institution = tokens.find((t) => t.institution !== undefined)?.institution ?? null;
+    const named = promoted && tokens.some((t) => t.promoted === true && t.place !== undefined);
+    const location = read === null || named ? null : read;
+    const carried = read !== null && named && declaredQualifier(sn1, tail?.at) ? read : location;
+    const concerns = [];
+    const first = tokens.findIndex((t) => t.cls === "NAME_PART");
+    const last = tokens.map((t) => t.cls).lastIndexOf("NAME_PART");
+    if (tokens.some((t, i) => t.cls === "INSTITUTION_TYPE" && i > first && i < last))
+      concerns.push("institution-inside-name");
+    if (promoted)
+      concerns.push("promoted-name");
+    if (parts.length === 0)
+      concerns.push("no-name-part");
+    if (truncated || cutPlace)
+      concerns.push("truncated-tail");
+    if (lexicon === undefined)
+      concerns.push("lexicon-absent");
+    if (lexiconPlace)
+      concerns.push("place-from-lexicon");
+    if (parts.some((p) => p.lexicon?.ambiguous === true || p.parts.some((c) => c.lexicon?.ambiguous)))
+      concerns.push("ambiguous-part");
+    return materialize({
+      sn0: print,
+      sn1,
+      sn2: renderSn2(tokens, built, institution, location),
+      sn3: renderKey(keys, institution, location, true),
+      sn4: renderKey(members, institution, location, false),
+      parts,
+      keys: members,
+      institution,
+      location: carried,
+      refusal: null,
+      empty: false,
+      surnames: surnamesOf(parts),
+      concerns,
+      initials: initialsOf(tokens, declared),
+      ...location === null || tail === null ? {} : { locationAt: tail.at }
+    });
+  }
+  let cache = new Map;
+  let capacity = options.capacity ?? DEFAULT_SCHOOL_NAME_CAPACITY;
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+  function schoolName(print) {
+    const hit = cache.get(print);
+    if (hit !== undefined) {
+      hits++;
+      return hit;
+    }
+    misses++;
+    const built = build(print);
+    if (capacity > 0) {
+      if (cache.size >= capacity) {
+        const oldest = cache.keys().next();
+        if (!oldest.done) {
+          cache.delete(oldest.value);
+          evictions++;
+        }
+      }
+      cache.set(print, built);
+    }
+    return built;
+  }
+  function schoolNameStats() {
+    return { hits, misses, evictions };
+  }
+  function resetSchoolNameCache(next) {
+    cache = new Map;
+    hits = 0;
+    misses = 0;
+    evictions = 0;
+    if (next !== undefined)
+      capacity = next;
+  }
+  return {
+    lexicon,
+    schoolName,
+    schoolNameStats,
+    resetSchoolNameCache,
+    capacity: () => capacity
+  };
+}
+var DEFAULT_SCHOOL_NAME_READER = Object.freeze(createSchoolNameReader());
+var LADDER = new Set(["sn0", "sn1", "sn2", "sn3", "sn4"]);
+function schoolTokensAt(name, dop) {
+  if (dop === "realWords")
+    return realWords(name);
+  if (dop === "surnames")
+    return name.surnames();
+  return [name[dop]];
+}
+var UNIT = String.fromCharCode(31);
+function keyAt(name, dop) {
+  return schoolTokensAt(name, dop).join(UNIT);
+}
+function comparable(name) {
+  return name.isSchool() && !name.isEmpty();
+}
+function keyTokens(name, dop) {
+  if (!comparable(name))
+    return null;
+  const tokens = schoolTokensAt(name, dop).filter((t) => t !== "");
+  return tokens.length > 0 ? tokens : null;
+}
+function requireLexicon(dop, ...names) {
+  if (dop !== "surnames")
+    return;
+  if (!names.some((n) => n.concerns.includes("lexicon-absent")))
+    return;
+  throw new Error('probablySameSchool at "surnames" needs a lexicon: read the schools with one ' + "(createSchoolNameReader({ lexicon })). " + "Without one every print answers [] and every pair would compare equal.");
+}
+function probablySameSchool(a, b, dop) {
+  requireLexicon(dop, a, b);
+  const x = keyTokens(a, dop);
+  const y = keyTokens(b, dop);
+  if (x === null || y === null || x.length !== y.length)
+    return false;
+  for (let i = 0;i < x.length; i++)
+    if (x[i] !== y[i])
+      return false;
+  return true;
+}
+var LONG_GENERICS = [
+  ...[...SCHOOL_INSTITUTION_VOCABULARY].filter(([, v]) => v.kind === "word").map(([k]) => k),
+  ...[...SCHOOL_FLUFF_VOCABULARY.values()].filter((v) => v.kind === "word").map((v) => v.canonical)
+].filter((w) => w.length >= 6);
+function oneEditApart(x, y) {
+  if (x === y || Math.abs(x.length - y.length) > 1)
+    return false;
+  let i = 0;
+  while (i < x.length && i < y.length && x[i] === y[i])
+    i++;
+  if (x.length === y.length) {
+    if (x.slice(i + 1) === y.slice(i + 1))
+      return true;
+    return x[i] === y[i + 1] && x[i + 1] === y[i] && x.slice(i + 2) === y.slice(i + 2);
+  }
+  return x.length > y.length ? x.slice(i + 1) === y.slice(i) : x.slice(i) === y.slice(i + 1);
+}
+function damagedGeneric(token) {
+  const t = token.toLocaleLowerCase();
+  return LONG_GENERICS.some((w) => oneEditApart(t, w));
+}
+function differOnlyByDamagedGenerics(a, b) {
+  if (!comparable(a) || !comparable(b))
+    return false;
+  const x = new Set(realWords(a));
+  const y = new Set(realWords(b));
+  const shared = [...x].filter((t) => y.has(t));
+  if (shared.length === 0)
+    return false;
+  const extra = [...x, ...y].filter((t) => !(x.has(t) && y.has(t)));
+  return extra.length > 0 && extra.every(damagedGeneric);
+}
+function foldPrint(print) {
+  return print.normalize("NFKD").replace(/\p{M}/gu, "").toLocaleLowerCase().replace(/['`\u2019]/g, "").replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function isColumnCutOf(a, b) {
+  if (!comparable(a) || !comparable(b))
+    return false;
+  const cutFrom = (cut, whole) => {
+    const c = foldPrint(cut.sn0);
+    const w = foldPrint(whole.sn0);
+    if (c.length === 0 || c.length >= w.length || !w.startsWith(c))
+      return false;
+    if (w[c.length] === " ")
+      return false;
+    const words = realWords(cut);
+    const held = new Set(realWords(whole));
+    return words.length > 0 && words.every((t) => held.has(t));
+  };
+  return cutFrom(a, b) || cutFrom(b, a);
+}
+function isInitialismOf(a, b, which) {
+  if (!comparable(a) || !comparable(b))
+    return false;
+  const spells = (bare, full) => {
+    const words = realWords(bare);
+    if (words.length !== 1 || realWords(full).length === 0)
+      return false;
+    const token = words[0];
+    if (probablySameSchool(bare, full, "realWords"))
+      return false;
+    const { declared, derived } = schoolInitials(full);
+    if (declared === token)
+      return true;
+    return which === "derived" && derived.includes(token);
+  };
+  return spells(a, b) || spells(b, a);
+}
+function sameInEveryPart(a, b) {
+  if (!probablySameSchool(a, b, "realWords"))
+    return false;
+  if (a.institution !== b.institution)
+    return false;
+  if (a.location === null || b.location === null)
+    return a.location === b.location;
+  if (placeRelation2(a.location, b.location) === "same")
+    return true;
+  return sameReading2(a.location, b.location);
+}
+function schoolCompare(a, b, dop) {
+  requireLexicon(dop, a, b);
+  const x = keyAt(a, dop);
+  const y = keyAt(b, dop);
+  if (x < y)
+    return -1;
+  return x > y ? 1 : 0;
+}
+var loner = 0;
+function slotOf(name, dop) {
+  requireLexicon(dop, name);
+  const tokens = keyTokens(name, dop);
+  return tokens === null ? null : tokens.join(UNIT);
+}
+function setOfSchools(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(`${UNIT}${UNIT}${loner++}`, 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 mapOfSchools(dop, entries) {
+  const held = new Map;
+  const map = {
+    dop,
+    get size() {
+      return held.size;
+    },
+    get: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? undefined : held.get(slot)?.[1];
+    },
+    has: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? false : held.has(slot);
+    },
+    set(name, value) {
+      const slot = slotOf(name, dop);
+      if (slot === null) {
+        held.set(`${UNIT}${UNIT}${loner++}`, [name, value]);
+        return this;
+      }
+      const found = held.get(slot);
+      if (found === undefined)
+        held.set(slot, [name, value]);
+      else
+        found[1] = value;
+      return this;
+    },
+    delete: (name) => {
+      const slot = slotOf(name, dop);
+      return slot === null ? false : held.delete(slot);
+    },
+    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;
+}
+var SCHOOL_LEVEL_COLUMNS = ["sn0", "sn1", "sn2", "sn3", "sn4", "realWords"];
+function schoolColumns(name) {
+  return {
+    sn0: slotOf(name, "sn0"),
+    sn1: slotOf(name, "sn1"),
+    sn2: slotOf(name, "sn2"),
+    sn3: slotOf(name, "sn3"),
+    sn4: slotOf(name, "sn4"),
+    realWords: slotOf(name, "realWords")
+  };
+}
+function isLadderLevel(dop) {
+  return LADDER.has(dop);
+}
+function schoolEncoder(options = {}) {
+  const reader = options.reader ?? DEFAULT_SCHOOL_NAME_READER;
+  const printCol = options.print ?? "print";
+  return {
+    columns: [printCol, ...SCHOOL_LEVEL_COLUMNS, "matchKey"],
+    levels: SCHOOL_LEVEL_COLUMNS,
+    indexed: [...SCHOOL_LEVEL_COLUMNS, "matchKey"],
+    encode(x) {
+      const key = foldSchoolName(x.sn0);
+      return { [printCol]: x.sn0, ...schoolColumns(x), matchKey: key === "" ? null : key };
+    },
+    key: (x, level) => schoolColumns(x)[level],
+    decode: (row) => reader.schoolName(row[printCol] ?? "")
+  };
+}
+function compareSchoolNames(a, b, reader) {
+  return compareSchools(reader.schoolName(a), reader.schoolName(b));
+}
+function compareSchools(a, b) {
+  if (!a.isSchool() || !b.isSchool())
+    return { verdict: "AMBIGUOUS", reason: "no-school", sharesNameParts: false };
+  if (realWords(a).length === 0 || realWords(b).length === 0)
+    return { verdict: "AMBIGUOUS", reason: "no-name-part", sharesNameParts: false };
+  const cut = isColumnCutOf(a, b);
+  if (!cut && !probablySameSchool(a, b, "realWords")) {
+    if (differOnlyByDamagedGenerics(a, b))
+      return { verdict: "AMBIGUOUS", reason: "damaged-generic-word", sharesNameParts: true };
+    if (isInitialismOf(a, b, "derived")) {
+      if (a.location !== null && b.location !== null) {
+        if (placeRelation2(a.location, b.location) === "conflict")
+          return { verdict: "BLOCKED", reason: "location-conflict", sharesNameParts: true };
+      }
+      return isInitialismOf(a, b, "declared") ? { verdict: "CANDIDATE", reason: "declared-initialism", sharesNameParts: true } : { verdict: "AMBIGUOUS", reason: "derived-initialism", sharesNameParts: true };
+    }
+    return { verdict: "DIFFERENT", reason: "name-parts-differ", sharesNameParts: false };
+  }
+  const sharesNameParts = true;
+  if (a.institution !== null && b.institution !== null && a.institution !== b.institution)
+    return { verdict: "BLOCKED", reason: "institution-type-conflict", sharesNameParts };
+  if (a.location !== null && b.location !== null) {
+    if (placeRelation2(a.location, b.location) === "conflict")
+      return { verdict: "BLOCKED", reason: "location-conflict", sharesNameParts };
+  }
+  if (a.institution === null !== (b.institution === null))
+    return { verdict: "AMBIGUOUS", reason: "unqualified-vs-qualified", sharesNameParts };
+  if (a.location === null !== (b.location === null))
+    return { verdict: "AMBIGUOUS", reason: "unqualified-vs-qualified", sharesNameParts };
+  if (a.concerns.includes("promoted-name") || b.concerns.includes("promoted-name"))
+    return { verdict: "AMBIGUOUS", reason: "promoted-token-identity", sharesNameParts };
+  if (cut && !probablySameSchool(a, b, "realWords"))
+    return { verdict: "CANDIDATE", reason: "truncated-print", sharesNameParts };
+  return { verdict: "CANDIDATE", reason: "same-name-and-type", sharesNameParts };
+}
+export {
+  DEFAULT_SCHOOL_NAME_CAPACITY,
+  DEFAULT_SCHOOL_NAME_READER,
+  NOT_A_SCHOOL,
+  SCHOOL_LEVEL_COLUMNS,
+  SCHOOL_NAME_EXCEPTIONS,
+  compareSchoolNames,
+  compareSchools,
+  createSchoolNameReader,
+  foldSchoolName,
+  hasSpecificToken,
+  isColumnCutOf,
+  isInitialismOf,
+  isLadderLevel,
+  mapOfSchools,
+  probablySameSchool,
+  realWords,
+  realWordsInPrintOrder,
+  sameInEveryPart,
+  schoolColumns,
+  schoolCompare,
+  schoolEncoder,
+  schoolInitials,
+  schoolKeyTokens,
+  schoolPrintSplit,
+  schoolTokensAt,
+  setOfSchools
+};