@finbheara/domain 0.0.0-stage → 0.2.0

package/dist/age.js

@@ -0,0 +1,420 @@
+var YOUNGEST_FLOOR = 0;
+var ADULT_FLOOR = 18;
+var MAJORS_FLOOR_YEARS = 3;
+var UNDER_CAP = Object.freeze({ plain: 2, exceptional: 4 });
+var UNDER_CAP_MAX_TOP = 21;
+var YOUNG_FLOOR = Object.freeze({ hard: 2, soft: 4 });
+var MIN_MAJOR_AGE = 4;
+var MIN_FEIS_AGE = 3;
+var DANCE_UP_YEARS = 1;
+var ageOnJanuary1 = (year, born) => year - born - 1;
+var yearsSinceBirth = (year, born) => year - born;
+var UNDER = /^(?:u|under\s*)(\d+)$/i;
+var OVER = /^(?:o|over\s*)(\d+)$/i;
+var RANGE = /^u?(\d+)\s*[-–]\s*(\d+)$/i;
+var ADULT_WORD = /^(?:adults?|ad|advanced|masters?)$/i;
+var SENIOR_WORD = /^seniors?$/i;
+var NO_LADDER = Object.freeze({ caps: [], overs: [], ranges: [] });
+function maxWhere(xs, pred) {
+  let best;
+  for (const x of xs)
+    if (pred(x) && (best === undefined || x > best))
+      best = x;
+  return best;
+}
+function minWhere(xs, pred) {
+  let best;
+  for (const x of xs)
+    if (pred(x) && (best === undefined || x < best))
+      best = x;
+  return best;
+}
+function readRange(a, b, ladder) {
+  if (!Number.isFinite(a) || !Number.isFinite(b) || b <= a)
+    return {
+      kind: "range",
+      interval: null,
+      refusal: "backwards-range",
+      clauses: [],
+      parts: [a, b]
+    };
+  const overlapping = ladder.ranges.includes(a) || ladder.ranges.includes(b + 1);
+  const bottom = !ladder.caps.some((c) => c <= a);
+  const atAdultFloor = bottom && a >= ADULT_FLOOR;
+  const youngest = bottom && !atAdultFloor;
+  const onRung = ladder.caps.includes(a);
+  const floor = overlapping || atAdultFloor || onRung ? a : Math.max(YOUNGEST_FLOOR, a - 1);
+  const clauses = [overlapping ? "range-overlapping" : "range-inclusive"];
+  if (youngest)
+    clauses.push("youngest-absorbs");
+  else if (atAdultFloor)
+    clauses.push("range-adult-floor");
+  else if (!overlapping)
+    clauses.push(onRung ? "range-floor-on-rung" : "range-floor-widened");
+  return {
+    kind: "range",
+    interval: { lo: youngest ? YOUNGEST_FLOOR : floor, hi: overlapping ? b : b + 1 },
+    refusal: null,
+    clauses,
+    parts: [a, b]
+  };
+}
+function read(token, ladder, top) {
+  const r = RANGE.exec(token);
+  if (r !== null)
+    return readRange(Number(r[1]), Number(r[2]), ladder);
+  if (ADULT_WORD.test(token))
+    return {
+      kind: "adult",
+      interval: { lo: ADULT_FLOOR, hi: Number.POSITIVE_INFINITY },
+      refusal: null,
+      clauses: ["and-over-no-ceiling"],
+      parts: []
+    };
+  if (SENIOR_WORD.test(token)) {
+    const top = maxWhere(ladder.caps, () => true);
+    return top === undefined ? { kind: "senior", interval: null, refusal: "senior-without-ladder", clauses: [], parts: [] } : {
+      kind: "senior",
+      interval: { lo: top, hi: Number.POSITIVE_INFINITY },
+      refusal: null,
+      clauses: ["and-over-no-ceiling"],
+      parts: []
+    };
+  }
+  const u = UNDER.exec(token);
+  if (u !== null) {
+    const n = Number(u[1]);
+    const below = maxWhere(ladder.caps, (c) => c < n);
+    return {
+      kind: "under",
+      interval: { lo: below ?? YOUNGEST_FLOOR, hi: n },
+      refusal: null,
+      clauses: [below === undefined ? "youngest-absorbs" : "under-floored-on-rung"],
+      parts: [n]
+    };
+  }
+  const o = OVER.exec(token);
+  if (o !== null) {
+    const n = Number(o[1]);
+    const above = top ? undefined : minWhere(ladder.overs, (c) => c > n);
+    if (above === undefined)
+      return {
+        kind: "over",
+        interval: { lo: n, hi: Number.POSITIVE_INFINITY },
+        refusal: null,
+        clauses: ["and-over-no-ceiling"],
+        parts: [n]
+      };
+    const gapped = ladder.caps.length > 0 && !ladder.caps.some((c) => c > n && c < above);
+    return {
+      kind: "over",
+      interval: { lo: n, hi: gapped ? Number.POSITIVE_INFINITY : above },
+      refusal: null,
+      clauses: [gapped ? "over-ceiling-refused-gap" : "over-ceiling-from-next-over"],
+      parts: [n]
+    };
+  }
+  return { kind: null, interval: null, refusal: "not-a-band", clauses: [], parts: [] };
+}
+
+class AgeMisuseError extends Error {
+  misuse;
+  constructor(misuse, detail) {
+    super(`age: ${misuse}: ${detail}`);
+    this.name = "AgeMisuseError";
+    this.misuse = misuse;
+  }
+}
+var display = (iv) => `[${iv.lo},${iv.hi === Number.POSITIVE_INFINITY ? "∞" : iv.hi})`;
+var currentYear = () => new Date().getUTCFullYear();
+function withRelations(a) {
+  const self = a;
+  return Object.assign(self, {
+    fitsIn: (container) => {
+      if (isAveraged(container))
+        throw new AgeMisuseError("average-as-container", `${self.ag2} cannot fit inside an average age (${String(container)}); an average is not a dancer`);
+      const r = ageRelation(self, container);
+      return r.relation === "same" || r.reason === "b-contains-a";
+    },
+    overlaps: (other) => {
+      const r = ageRelation(self, other).relation;
+      return r === "same" || r === "contains" || r === "overlaps";
+    }
+  });
+}
+function fromPrint(print, context = {}) {
+  const ladder = context.ladder ?? NO_LADDER;
+  const year = context.year === undefined ? currentYear() : context.year;
+  const ag1 = print.trim().toLowerCase();
+  const reading = ag1 === "" ? { kind: null, interval: null, refusal: null, clauses: [], parts: [] } : read(print.trim(), ladder, context.top === true);
+  const iv = reading.interval;
+  const arm = ag1 === "" ? "empty" : iv === null ? "open" : "band";
+  const ag2 = iv !== null ? display(iv) : ag1 === "" ? "" : `${ag1}?`;
+  const source = sourceOf(reading);
+  return withRelations({
+    [Symbol.toStringTag]: "Age",
+    toString: () => ag2,
+    arm,
+    kind: reading.kind,
+    ag0: print,
+    ag1,
+    ag2,
+    parts: reading.parts,
+    length: ag2.length,
+    refusal: reading.refusal,
+    source,
+    clauses: reading.clauses,
+    ladder,
+    year,
+    isEmpty: () => arm === "empty",
+    isAge: () => iv !== null,
+    isExact: () => {
+      if (iv === null || year === null)
+        return false;
+      const b = birthYearsOfInterval(iv, year);
+      return b.from !== null && b.from === b.to;
+    },
+    isAndOver: () => iv !== null && iv.hi === Number.POSITIVE_INFINITY,
+    isAdult: () => reading.kind === "adult",
+    interval: () => iv,
+    birthYears: (y) => {
+      const at = y ?? year;
+      if (at === null)
+        throw new Error(`Age.from(${JSON.stringify(print)}): birthYears needs a competition year`);
+      return birthYearsOfInterval(iv, at);
+    },
+    floorObserved: () => reading.kind !== "under" || iv === null ? null : reading.clauses.includes("under-floored-on-rung")
+  });
+}
+function fromYOB(from, to = from) {
+  for (const y of [from, to])
+    if (y !== null && !Number.isInteger(y))
+      throw new RangeError(`Age.fromYOB(${from}, ${to}): a year of birth is a whole number`);
+  if (from === null && to === null)
+    throw new RangeError("Age.fromYOB(null, null): at least one end is a year");
+  if (from !== null && to !== null && from > to)
+    throw new RangeError(`Age.fromYOB(${from}, ${to}): the earliest year comes first`);
+  const exact = from !== null && from === to;
+  const ag0 = exact ? String(from) : `${from ?? ""}..${to ?? ""}`;
+  const ag2 = `b${ag0}`;
+  const years = Object.freeze({ from, to });
+  return withRelations({
+    [Symbol.toStringTag]: "Age",
+    toString: () => ag2,
+    arm: "yob",
+    kind: "yob",
+    ag0,
+    ag1: ag0,
+    ag2,
+    parts: exact ? [from] : [from, to].filter((y) => y !== null),
+    length: ag2.length,
+    refusal: null,
+    source: "printed-yob",
+    clauses: [],
+    ladder: NO_LADDER,
+    year: null,
+    isEmpty: () => false,
+    isAge: () => true,
+    isExact: () => exact,
+    isAndOver: () => from === null,
+    isAdult: () => false,
+    interval: () => null,
+    birthYears: () => years,
+    floorObserved: () => null
+  });
+}
+var Age = Object.freeze({ from: fromPrint, fromYOB });
+function sourceOf(r) {
+  const iv = r.interval;
+  if (iv === null)
+    return "open";
+  switch (r.kind) {
+    case "range":
+      return "printed-range";
+    case "over":
+      return iv.hi === Number.POSITIVE_INFINITY ? "printed-band" : "sibling-narrowed";
+    case "adult":
+    case "senior":
+      return "printed-band";
+    case "under":
+      return iv.lo > YOUNGEST_FLOOR ? "sibling-narrowed" : "printed-band";
+    default:
+      return "open";
+  }
+}
+function birthYearsOfInterval(iv, year) {
+  if (iv === null)
+    return { from: null, to: null };
+  return {
+    from: iv.hi === Number.POSITIVE_INFINITY ? null : year - iv.hi,
+    to: Math.min(year - iv.lo - 1, year - MAJORS_FLOOR_YEARS)
+  };
+}
+var inBirthYears = (a) => a.arm === "yob" || a.year !== null;
+function spanOf(a) {
+  if (!a.isAge())
+    return null;
+  if (inBirthYears(a)) {
+    const b = a.birthYears();
+    return {
+      lo: b.from ?? Number.NEGATIVE_INFINITY,
+      hi: b.to ?? Number.POSITIVE_INFINITY
+    };
+  }
+  const iv = a.interval();
+  return { lo: iv.lo, hi: iv.hi - 1 };
+}
+function ageRelation(a, b) {
+  for (const x of [a, b])
+    if (isAveraged(x))
+      throw new AgeMisuseError("average-in-relation", `${String(x)} is an average, not a dancer's birth years; ask its fitsIn`);
+  if (inBirthYears(a) !== inBirthYears(b))
+    throw new Error("ageRelation: one reading is in birth years and the other has no competition year; read both with a year, or neither");
+  if (!a.isAge())
+    return { relation: "silent", reason: "a-not-a-band" };
+  if (!b.isAge())
+    return { relation: "silent", reason: "b-not-a-band" };
+  const sa = spanOf(a);
+  const sb = spanOf(b);
+  const years = inBirthYears(a);
+  if (sa.hi < sb.lo)
+    return { relation: "disjoint", reason: years ? "a-older" : "a-younger" };
+  if (sb.hi < sa.lo)
+    return { relation: "disjoint", reason: years ? "a-younger" : "a-older" };
+  if (sa.lo === sb.lo && sa.hi === sb.hi)
+    return { relation: "same", reason: "equal" };
+  if (sa.lo <= sb.lo && sb.hi <= sa.hi)
+    return { relation: "contains", reason: "a-contains-b" };
+  if (sb.lo <= sa.lo && sa.hi <= sb.hi)
+    return { relation: "contains", reason: "b-contains-a" };
+  return { relation: "overlaps", reason: "partial" };
+}
+function canOverlap(...ages) {
+  for (let i = 0;i < ages.length; i++)
+    for (let j = i + 1;j < ages.length; j++)
+      if (ageRelation(ages[i], ages[j]).relation === "disjoint")
+        return false;
+  return true;
+}
+var AVERAGE_AGE_DECIMALS = 2;
+var HUNDREDTHS = 10 ** AVERAGE_AGE_DECIMALS;
+function roundedMeanHundredths(k, n) {
+  if (!Number.isInteger(k) || !Number.isInteger(n) || n <= 0)
+    throw new RangeError(`roundedMeanHundredths(${k}, ${n}): whole numbers, n > 0`);
+  return Math.floor((2 * HUNDREDTHS * k + n) / (2 * n));
+}
+function isAveraged(a) {
+  return a[Symbol.toStringTag] === "AverageAge";
+}
+function averageAge(ages) {
+  if (ages.length === 0)
+    throw new AgeMisuseError("empty-average", "averageAge needs at least one exact age");
+  let sum = 0;
+  for (const [i, a] of ages.entries()) {
+    if (isAveraged(a))
+      throw new AgeMisuseError("average-of-averages", `input ${i} (${String(a)}) is already an average; average the members instead`);
+    if (!a.isExact())
+      throw new AgeMisuseError("not-exact", `input ${i} (${String(a)}) is not one birth year; an average takes exact ages only`);
+    sum += a.birthYears().from;
+  }
+  const n = ages.length;
+  const members = Object.freeze([...ages]);
+  const hundredths = (year) => roundedMeanHundredths(n * (year - 1) - sum, n);
+  const self = {
+    [Symbol.toStringTag]: "AverageAge",
+    provenance: `average of ${n}`,
+    members,
+    n,
+    birthYearSum: sum,
+    meanBirthYear: sum / n,
+    toString: () => `avg(${n}):b${sum / n}`,
+    isExact: () => false,
+    meanAgeHundredths: hundredths,
+    meanAge: (year) => hundredths(year) / HUNDREDTHS,
+    fitsIn: (container) => {
+      if (isAveraged(container))
+        throw new AgeMisuseError("average-as-container", `nothing fits inside an average age (${String(container)})`);
+      if (container.year === null)
+        throw new AgeMisuseError("average-container-no-year", `${String(container)} has no competition year to take the average age in`);
+      const iv = container.interval();
+      if (iv === null)
+        return false;
+      const h = hundredths(container.year);
+      return iv.lo * HUNDREDTHS <= h && h < iv.hi * HUNDREDTHS;
+    },
+    birthYears: () => {
+      throw new AgeMisuseError("average-birth-years", `an average of ${n} has no year of birth; read meanBirthYear, which is not a dancer's`);
+    }
+  };
+  return self;
+}
+function birthYearsDisjoint(a, b) {
+  if (a.to !== null && b.from !== null && a.to < b.from)
+    return true;
+  if (b.to !== null && a.from !== null && b.to < a.from)
+    return true;
+  return false;
+}
+function birthYearsMeet(card, other, slack = 0) {
+  if (card.from !== null && other.to !== null && card.from > other.to)
+    return false;
+  if (card.to !== null && other.from !== null && card.to + slack < other.from)
+    return false;
+  return true;
+}
+function underCapApplies(bandFrom, year) {
+  return bandFrom !== null && year - bandFrom <= UNDER_CAP_MAX_TOP;
+}
+function underCappedYears(b, year, n = UNDER_CAP.plain) {
+  if (n > UNDER_CAP.exceptional)
+    throw new Error(`under-cap: ${n} is over the exceptional cap of ${UNDER_CAP.exceptional}`);
+  if (!underCapApplies(b.from, year))
+    return b;
+  const cap = b.from + n;
+  if (b.to !== null && b.to <= cap)
+    return b;
+  return { from: b.from, to: cap };
+}
+function underCapRefuses(bandFrom, identityFrom, n) {
+  return identityFrom > bandFrom + n;
+}
+function youngFloor(year, oldest) {
+  const s = yearsSinceBirth(year, oldest);
+  if (s >= YOUNG_FLOOR.soft)
+    return "clear";
+  if (s < YOUNG_FLOOR.hard)
+    return "too-young";
+  return "same-school-only";
+}
+var tooYoungForMajor = (year, oldest) => yearsSinceBirth(year, oldest) < MIN_MAJOR_AGE;
+var tooYoungForFeis = (year, oldest) => yearsSinceBirth(year, oldest) < MIN_FEIS_AGE;
+export {
+  ADULT_FLOOR,
+  AVERAGE_AGE_DECIMALS,
+  Age,
+  AgeMisuseError,
+  DANCE_UP_YEARS,
+  MAJORS_FLOOR_YEARS,
+  MIN_FEIS_AGE,
+  MIN_MAJOR_AGE,
+  UNDER_CAP,
+  UNDER_CAP_MAX_TOP,
+  YOUNGEST_FLOOR,
+  YOUNG_FLOOR,
+  ageOnJanuary1,
+  ageRelation,
+  averageAge,
+  birthYearsDisjoint,
+  birthYearsMeet,
+  birthYearsOfInterval,
+  canOverlap,
+  isAveraged,
+  roundedMeanHundredths,
+  tooYoungForFeis,
+  tooYoungForMajor,
+  underCapApplies,
+  underCapRefuses,
+  underCappedYears,
+  yearsSinceBirth,
+  youngFloor
+};

package/dist/ceili.js

@@ -0,0 +1,15 @@
+import {
+  CEILI_NODES2,
+  allCeilis2,
+  ceiliById2,
+  ceili2,
+  ceiliRelation2
+} from "./chunks/place-7gqecaxd.js";
+import"./chunks/place-g6yw4cq6.js";
+export {
+  CEILI_NODES2 as CEILI_NODES,
+  allCeilis2 as allCeilis,
+  ceili2 as ceili,
+  ceiliById2 as ceiliById,
+  ceiliRelation2 as ceiliRelation
+};

package/dist/chunks/place-7gqecaxd.js

@@ -0,0 +1,201 @@
+import {
+  foldDancePrint,
+  matchNodes,
+  candidateRelation,
+  isDanceTypePrint2
+} from "./place-g6yw4cq6.js";
+
+function node(id, name, irish, family, formation, opts = {}) {
+  const kind = "round" in formation ? "round" : ("long" in formation) ? "long" : "set";
+  return Object.freeze({
+    id,
+    name,
+    irish,
+    prints: Object.freeze(opts.prints ?? []),
+    irishPrints: Object.freeze(opts.irishPrints ?? []),
+    formation: kind,
+    hands: "hands" in formation ? formation.hands : null,
+    setHands: "setHands" in formation ? formation.setHands : null,
+    family
+  });
+}
+var CEILI_NODES2 = Object.freeze([
+  node("walls-of-limerick", "The Walls of Limerick", "Ballaí Luimní", "handbook", { long: true, setHands: 4 }, {
+    prints: ["Walls of Limerick"],
+    irishPrints: ["Balla Luimní"]
+  }),
+  node("four-hand-reel", "The Four-Hand Reel", "Cor Ceathrar", "four-hand", { hands: 4 }, {
+    prints: ["Four Hand Reel", "4 Hand Reel"],
+    irishPrints: ["Cor Ceathrair", "An Ríl Ceathrair"]
+  }),
+  node("eight-hand-reel", "The Eight Hand Reel", "Cor Ochtar", "eight-hand", { hands: 8 }, {
+    prints: ["8-Hand Reel", "Eight-Hand Reel"],
+    irishPrints: ["An Cor Octair"]
+  }),
+  node("morris-reel", "Morris Reel", "Cor Muirghéis", "eight-hand", { hands: 8 }, {
+    prints: ["The Morris Reel"]
+  }),
+  node("high-cauled-cap", "High Cauled Cap", "Cadhp an Chúil Áird", "eight-hand", { hands: 8 }, {
+    prints: ["High-Cauled Cap"],
+    irishPrints: ["Caip an Chúil Aird"]
+  }),
+  node("sixteen-hand-reel", "The Sixteen Hand Reel", "Cor Sé Dhuine Dhéag", "handbook", { hands: 16 }, {
+    prints: ["Sixteen-Hand Reel"]
+  }),
+  node("humours-of-bandon", "Humours of Bandon", "Pléaracha na Bandan", "four-hand", { hands: 4 }),
+  node("eight-hand-jig", "Eight Hand Jig", "Port Ochtar", "eight-hand", { hands: 8 }, {
+    prints: ["8-Hand Jig", "The Eight Hand Jig"],
+    irishPrints: ["An Port Ochtair"]
+  }),
+  node("siege-of-ennis", "Siege of Ennis", "Ionsaí na hInse", "handbook", {
+    long: true,
+    setHands: 8
+  }),
+  node("harvest-time-jig", "Harvest-Time Jig", "Port an Fhómhair", "handbook", { long: true, setHands: 6 }, {
+    prints: ["Harvest Time Jig"]
+  }),
+  node("rince-fada", "Rince Fada", "Rince Fada", "handbook", { long: true, setHands: 4 }, {
+    prints: ["Long Dance"]
+  }),
+  node("bridge-of-athlone", "The Bridge of Athlone", "Droichead Átha Luain", "handbook", {
+    long: true,
+    setHands: 4
+  }),
+  node("haste-to-the-wedding", "Haste to the Wedding", "Deifir na Bainise", "handbook", {
+    long: true,
+    setHands: 4
+  }),
+  node("siege-of-carrick", "The Siege of Carrick", "Briseadh na Carraige", "handbook", {
+    long: true,
+    setHands: 4
+  }),
+  node("antrim-reel", "Antrim Reel", "Cor Aontroma", "handbook", { long: true, setHands: 4 }),
+  node("glencar-reel", "Glencar Reel", "Cor Gleann cearr", "handbook", { hands: 6 }),
+  node("three-tunes", "The Three Tunes", "Na Trí Foinn", "eight-hand", { hands: 8 }),
+  node("st-patricks-day", "St. Patrick's Day", "Lá Fhéile Phádraig", "eight-hand", { hands: 8 }, {
+    irishPrints: ["Lá Fhéíle Phádraig"]
+  }),
+  node("trip-to-the-cottage", "Trip to the Cottage", "Turas Chun An Tigh", "eight-hand", { hands: 8 }, {
+    irishPrints: ["Turas go dti an Teachin"]
+  }),
+  node("rince-mor", "An Rince Mór", "An Rince Mór", "handbook", { round: true }, {
+    prints: ["Big Dance"]
+  }),
+  node("haymakers-jig", "Haymakers' Jig", "Baint an Fhéir", "handbook", { hands: 10, long: true }, {
+    prints: ["The Haymakers Jig"]
+  }),
+  node("fairy-reel", "The Fairy Reel", "Cor na Sióg", "handbook", { long: true, setHands: 6 }, {
+    irishPrints: ["Cor na Siog"]
+  }),
+  node("duke-reel", "The Duke Reel", "Cor an Diuic", "handbook", { hands: 6 }),
+  node("lannigans-ball", "Lannigan's Ball", "Bainis Uí Lonagáín", "eight-hand", { hands: 12 }, {
+    irishPrints: ["Baineis Ui Lonagain"]
+  }),
+  node("cross-reel", "The Cross Reel", "An Cor Casta", "eight-hand", { hands: 8 }, {
+    prints: ["Cross Reel"]
+  }),
+  node("waves-of-tory", "The Waves of Tory", "Tonnaí Thoraigh", "handbook", {
+    long: true,
+    setHands: 4
+  }),
+  node("rakes-of-mallow", "The Rakes of Mallow", "Reici Mhala", "handbook", {
+    long: true,
+    setHands: 6
+  }),
+  node("gates-of-derry", "The Gates of Derry", "Geataí Dhoire", "eight-hand", { hands: 8 }, {
+    prints: ["Gates of Derry"]
+  }),
+  node("sweets-of-may", "The Sweets of May", "Aoibhneas na Bealtaine", "eight-hand", { hands: 8 }, {
+    irishPrints: ["Aoidhneas na Bealtaine"]
+  }),
+  node("bonfire-dance", "Bonfire Dance", "Rince Mór na Tine", "handbook", { round: true })
+]);
+function makeCeili(n) {
+  return Object.freeze({
+    [Symbol.toStringTag]: "Ceili",
+    id: n.id,
+    name: n.name,
+    irish: n.irish,
+    node: n,
+    toString: () => n.name,
+    hands: () => n.hands ?? (n.formation === "round" ? "round" : "long"),
+    setHands: () => n.setHands,
+    isLong: () => n.formation === "long",
+    family: () => n.family,
+    inHandbook: () => true
+  });
+}
+var CEILIS = Object.freeze(CEILI_NODES2.map(makeCeili));
+var CEILI_BY_ID = new Map(CEILIS.map((c) => [c.id, c]));
+var MATCHABLE = CEILIS.map((c) => ({
+  id: c.id,
+  ceili: c,
+  aliases: [c.name, ...c.node.prints, ...c.irish ? [c.irish] : [], ...c.node.irishPrints]
+}));
+function allCeilis2() {
+  return CEILIS;
+}
+function ceiliById2(id) {
+  return CEILI_BY_ID.get(id);
+}
+function narrow(cands, ctx, misses) {
+  let out = cands;
+  const step = (label, keep) => {
+    const next = out.filter(keep);
+    if (next.length > 0)
+      out = next;
+    else if (out.length > 0)
+      misses.push(label);
+  };
+  if (ctx.list)
+    step(`list:${ctx.list}`, (c) => c.family() === ctx.list);
+  if (ctx.hands !== undefined) {
+    const h = ctx.hands;
+    step(`hands:${h}`, (c) => {
+      const own = c.hands();
+      if (typeof own === "number")
+        return own === h || c.family() === "eight-hand" && h === 8;
+      return true;
+    });
+  }
+  return out;
+}
+function reading(print, folded, candidates, score, match, refusal, misses) {
+  return Object.freeze({
+    [Symbol.toStringTag]: "CeiliReading",
+    print,
+    folded,
+    candidates: Object.freeze([...candidates]),
+    score,
+    match,
+    refusal,
+    misses: Object.freeze([...misses]),
+    ceili: candidates.length === 1 ? candidates[0] : undefined,
+    isCeili: () => candidates.length > 0,
+    isSingular: () => candidates.length === 1,
+    isAmbiguous: () => candidates.length > 1,
+    refine(ctx) {
+      const m = [...misses];
+      return reading(print, folded, narrow(candidates, ctx, m), score, match, refusal, m);
+    },
+    toString: () => candidates.length === 1 ? candidates[0].name : `${print}?`
+  });
+}
+function ceili2(print, ctx = {}) {
+  const folded = foldDancePrint(print);
+  if (folded === "")
+    return reading(print, folded, [], 0, null, "empty", []);
+  if (isDanceTypePrint2(print))
+    return reading(print, folded, [], 0, null, "dance-type", []);
+  const m = matchNodes(folded, MATCHABLE);
+  if (m.nodes.length === 0)
+    return reading(print, folded, [], m.score, null, "unmatched", []);
+  const misses = [];
+  const cands = narrow(m.nodes.map((x) => x.ceili), ctx, misses);
+  return reading(print, folded, cands, m.score, m.kind, null, misses);
+}
+function ceiliRelation2(a, b) {
+  return candidateRelation(a.candidates.map((c) => c.id), b.candidates.map((c) => c.id));
+}
+
+export { CEILI_NODES2, allCeilis2, ceiliById2, ceili2, ceiliRelation2 };