@finbheara/domain 0.31.0 → 0.32.0

package/dist/chunks/place-8k74cr5j.js

@@ -0,0 +1,655 @@
+import {
+  validity
+} from "./place-q9kwsmzd.js";
+
+var LEAD_ID = /^\s*(?:comp(?:etition)?\.?\s*)?\d+[a-z]*(?:[/-]\d*[a-z]*)*\s*[-:.]?\s*/i;
+var PAREN = /\(([^)]*)\)/g;
+var AND_OVER = /(?<![0-9])(?<![0-9][a-z]*)(?<!(?:^|[^a-z0-9])[a-z])(\d{1,2})\s*(?:years?\s*)?(?:&|\+|\band\b)\s*(?:over|older|up|o)(?![a-z])/i;
+var OVER_WORD = /(?:\bover\s*|\bos\s+cionn\s*|(?<![a-z0-9])o[./]?\s*)(\d{1,2})(?![a-z0-9])/i;
+var OVER_GLUED = /(?<![a-z0-9])(\d{1,2})\s*o(?![a-z'’])/i;
+var OVER_PLUS = /(?<![a-z0-9])(\d{1,2})\s*\+/;
+var UNDER_WORD = String.raw`(?:\bund(?:er)?\.?\s*(?:age\s*)?|\bfaoi\s*|(?<![a-z0-9])u[./]?\s*)`;
+var UNDER = new RegExp(String.raw`${UNDER_WORD}(\d{1,2})(?![0-9])(?![a-z][a-z0-9])`, "i");
+var JOINED_CAPS = new RegExp(String.raw`${UNDER_WORD}\d{1,2}(?![0-9])(?:(?:\s*(?:&|,|\/|\band\b)\s*(?:${UNDER_WORD})?|\s+${UNDER_WORD})\d{1,2}(?![0-9]))+`, "i");
+var JOINED_NOT = /^(?:\s*(?:yrs?|years?|-?\s*hand)\b|[a-z])/i;
+var JOINED_OPEN = /^(?:\s*\+|\s*(?:&|and)\s*(?:o|over|older|up)\b)/i;
+var UNDER_STRIDE = /^\s*\/\s*0*([1-9]\d?)\s*yrs?(?![a-z0-9])/i;
+var AND_UNDER = /(?<![a-z0-9])(\d{1,2})\s*(?:years?\s*)?(?:&|\/|\band\b)\s*u(?:nder)?(?![a-z])(?!\s*\d)/i;
+var AND_UNDER_RANGE = /(?<![a-z0-9])(\d{1,2})\s*(?:&|\band\b)\s*under\s*(\d{1,2})(?![a-z0-9])/i;
+var AND_RANGE = /(?<![a-z0-9])(?<!\b(?:under|und|over|faoi|cionn|u|o)\.?\s*)(?<!\d\s*,\s*)(?<!\(\s*)(\d{1,2})\s*(?:&|\band\b)\s*(\d{1,2})(?![a-z0-9])(?!\s*-?\s*hand)(?!\s*(?:&|\+|\/|,|\)|\band\b|\bor\b))/i;
+var SLASH_RANGE = /(?<![a-z0-9/])(\d{1,2})\s*\/\s*(\d{1,2})(?=\s*(?:years?|yrs?|boys?|girls?|ladies|men)\b)/i;
+var AGE_N = /(?<!\b(?:under|over)\s*)\bage\s*(\d{1,2})(?![a-z0-9])(?!\s*-?\s*hand)/i;
+var YEARS = /(?<![a-z0-9])(?<!\d\s*(?:&|\/|\band\b|[-\u0096–—]|\bto\b)\s*)(\d{1,2})\s*(?:years?|yrs?)(?![a-z0-9])(?!\s*(?:&|\+|\/|\band\b|\bor\b|old))/i;
+var RANGE_DASH = String.raw`(?:\u00c2?[-\u0096–—]|\bto\b)`;
+var RANGE = new RegExp(String.raw`(?<![0-9])(?<![0-9][a-z]*)(?<!(?:^|[^a-z0-9])[a-z])(?:u\s*)?(\d{1,2})\s*${RANGE_DASH}\s*(\d{1,2})(?![a-z0-9])`, "i");
+var LEAD_RANGE = new RegExp(String.raw`^\s*([1-9]\d?)\s*${RANGE_DASH}\s*([1-9]\d?)(?![a-z0-9])(?!\s*[/&])`, "i");
+var ADULT_CODE = /^\s*a(?:(\d{1,2})(u|o|&o))?\s*$/i;
+var ADULT = /(?<!non[\s-])(?<!-)\b(?:adults?|advanced\s+adults?|masters?)\b/i;
+var SENIOR = /(?<!-)\bseniors?\b/i;
+var TITLE_RANGE_MIN2 = 3;
+var TITLE_RANGE_MAX2 = 40;
+var NONE = Object.freeze({ token: "", span: null });
+function at(title, offset, start, end, token) {
+  const a = offset + start;
+  const b = offset + end;
+  return { token, span: { start: a, end: b, text: title.slice(a, b) } };
+}
+function inFence(a, b) {
+  if (a.startsWith("0") || b.startsWith("0"))
+    return false;
+  const lo = Number(a);
+  const hi = Number(b);
+  return lo >= TITLE_RANGE_MIN2 && hi <= TITLE_RANGE_MAX2 && lo < hi;
+}
+function readJoined(title, s, offset) {
+  const j = JOINED_CAPS.exec(s);
+  if (j === null)
+    return null;
+  const end = j.index + j[0].length;
+  const tail = s.slice(end);
+  if (JOINED_NOT.test(tail))
+    return null;
+  const caps = [...j[0].matchAll(/\d{1,2}/g)].map((d) => Number(d[0]));
+  if (caps.some((c, i) => i > 0 && c < (caps[i - 1] ?? 0)))
+    return null;
+  if (JOINED_OPEN.test(tail))
+    return NONE;
+  return at(title, offset, j.index, end, `u${Math.max(...caps)}`);
+}
+function readAnchored(title, s, offset, aside = false) {
+  const joined = readJoined(title, s, offset);
+  if (joined !== null)
+    return joined;
+  for (const re of [AND_OVER, OVER_WORD, OVER_GLUED]) {
+    const m = re.exec(s);
+    if (m?.[1] !== undefined)
+      return at(title, offset, m.index, m.index + m[0].length, `o${Number(m[1])}`);
+  }
+  const u = AND_UNDER_RANGE.exec(s);
+  if (u?.[1] !== undefined && u[2] !== undefined && inFence(u[1], u[2]))
+    return at(title, offset, u.index, u.index + u[0].length, `${Number(u[1])}-${Number(u[2])}`);
+  const j = aside ? null : AND_RANGE.exec(s);
+  if (j?.[1] !== undefined && j[2] !== undefined && inFence(j[1], j[2]))
+    return at(title, offset, j.index, j.index + j[0].length, `${Number(j[1])}-${Number(j[2])}`);
+  const sl = aside ? null : SLASH_RANGE.exec(s);
+  if (sl?.[1] !== undefined && sl[2] !== undefined && inFence(sl[1], sl[2]) && Number(sl[2]) === Number(sl[1]) + 1)
+    return at(title, offset, sl.index, sl.index + sl[0].length, `${Number(sl[1])}-${Number(sl[2])}`);
+  const l = LEAD_RANGE.exec(s);
+  if (l?.[1] !== undefined && l[2] !== undefined && inFence(l[1], l[2])) {
+    const lead = l[0].length - l[0].trimStart().length;
+    return at(title, offset, lead, l[0].length, `${Number(l[1])}-${Number(l[2])}`);
+  }
+  const stripped = s.replace(LEAD_ID, "");
+  const shift = s.length - stripped.length;
+  const r = RANGE.exec(stripped);
+  if (r?.[1] !== undefined && r[2] !== undefined && inFence(r[1], r[2]))
+    return at(title, offset + shift, r.index, r.index + r[0].length, `${Number(r[1])}-${Number(r[2])}`);
+  const au = AND_UNDER.exec(s);
+  if (au?.[1] !== undefined)
+    return at(title, offset, au.index, au.index + au[0].length, `u${Number(au[1]) + 1}`);
+  const m = UNDER.exec(s);
+  if (m?.[1] !== undefined) {
+    const end = m.index + m[0].length;
+    const k = UNDER_STRIDE.exec(s.slice(end));
+    if (k?.[1] !== undefined)
+      return at(title, offset, m.index, end + k[0].length, `u${Number(m[1])}/${Number(k[1])}yr`);
+    return at(title, offset, m.index, end, `u${Number(m[1])}`);
+  }
+  const y = YEARS.exec(s) ?? AGE_N.exec(s);
+  if (y?.[1] !== undefined)
+    return at(title, offset, y.index, y.index + y[0].length, `u${Number(y[1]) + 1}`);
+  const p = OVER_PLUS.exec(s);
+  if (p?.[1] !== undefined)
+    return at(title, offset, p.index, p.index + p[0].length, `o${Number(p[1])}`);
+  const a = ADULT.exec(s);
+  if (a !== null)
+    return at(title, offset, a.index, a.index + a[0].length, "adult");
+  const n = SENIOR.exec(s);
+  if (n !== null)
+    return at(title, offset, n.index, n.index + n[0].length, "senior");
+  return NONE;
+}
+function ageTitleToken2(title) {
+  const s = title.trim();
+  if (s === "")
+    return NONE;
+  const lead = title.length - title.trimStart().length;
+  PAREN.lastIndex = 0;
+  let adultAside = null;
+  let adultWord = null;
+  for (const m of s.matchAll(PAREN)) {
+    const inner = m[1] ?? "";
+    const from = lead + (m.index ?? 0) + 1;
+    const i = m.index ?? 0;
+    const tail = i + m[0].length === s.length && !/[a-z0-9]/i.test(s[i - 1] ?? "");
+    const code = tail ? ADULT_CODE.exec(inner) : null;
+    if (code !== null) {
+      const split = code[1] === undefined ? "" : `${/u/i.test(code[2] ?? "") ? "u" : "o"}${code[1]}`;
+      const a = inner.length - inner.trimStart().length;
+      adultAside = at(title, from, a, inner.trimEnd().length, adultBeside2(split) ?? "adult");
+      continue;
+    }
+    if (adultWord !== null)
+      continue;
+    const t = readAnchored(title, inner, from, true);
+    if (t.token === "")
+      continue;
+    if (t.token === "adult") {
+      adultWord = t;
+      continue;
+    }
+    return adultOverUnder(title, s, lead, t);
+  }
+  if (adultWord !== null)
+    return adultAside ?? adultWord;
+  const words = readAnchored(title, s, lead);
+  return adultAside !== null && (words.token === "" || words.token === "adult") ? adultAside : adultOverUnder(title, s, lead, words);
+}
+var ADULT_UNDER_MIN = 18;
+var SENIOR_ADULT_OVER = /\bsenior\s+adult\b/i;
+function adultBeside2(band) {
+  const b = band.trim().toLowerCase();
+  if (b === "")
+    return "adult";
+  const u = /^u(\d+)(\/\d+yr)?$/.exec(b);
+  const n = u?.[1];
+  if (n !== undefined) {
+    if (Number(n) < ADULT_UNDER_MIN)
+      return;
+    return Number(n) > ADULT_UNDER_MIN ? `adult u${Number(n)}${u?.[2] ?? ""}` : "adult";
+  }
+  const floor = /^o(\d+)$/.exec(b)?.[1] ?? /^(\d+)-\d+$/.exec(b)?.[1];
+  if (floor === undefined)
+    return band;
+  return Number(floor) < ADULT_UNDER_MIN ? undefined : `adult ${b}`;
+}
+function adultOverUnder(title, s, lead, t) {
+  if (t.token === "")
+    return t;
+  const a = ADULT.exec(s);
+  if (a === null)
+    return t;
+  if (/^o\d+$/.test(t.token) && SENIOR_ADULT_OVER.test(s))
+    return t;
+  const token = adultBeside2(t.token);
+  if (token === undefined || token === t.token)
+    return t;
+  if (/^u\d+(?:\/\d+yr)?$/.test(t.token))
+    return at(title, lead, a.index, a.index + a[0].length, token);
+  return { token, span: t.span };
+}
+
+var YOUNGEST_FLOOR2 = 0;
+var ADULT_FLOOR2 = 18;
+var MAJORS_FLOOR_YEARS2 = 3;
+var UNDER_CAP2 = Object.freeze({ plain: 2, exceptional: 4 });
+var UNDER_CAP_MAX_TOP2 = 21;
+var YOUNG_FLOOR2 = Object.freeze({ hard: 2, soft: 4 });
+var MIN_MAJOR_AGE2 = 4;
+var MIN_FEIS_AGE2 = 3;
+var YOUNGEST_BAND_TOP2 = MAJORS_FLOOR_YEARS2;
+var YOB_RANGE2 = Object.freeze({ first: 1901, last: 2099 });
+var DANCE_UP_YEARS2 = 1;
+var ageOnJanuary12 = (year, born) => year - born - 1;
+var yearsSinceBirth2 = (year, born) => year - born;
+var UNDER2 = /^(?:u|under\s*)(\d+)(?:\/([1-9]\d*)yr)?$/i;
+var OVER = /^(?:o|over\s*)(\d+)$/i;
+var AND_OVER2 = /^(\d+)\s*(?:&|and\b)\s*(?:over|o)$/i;
+var RANGE2 = /^u?(\d+)\s*[-–]\s*(\d+)$/i;
+var ADULT_WORD = /^(?:adults?|ad|advanced|masters?)$/i;
+var ADULT_UNDER = /^(?:adults?|ad)[\s-]*(?:u|under\s*)(\d+)(?:\/([1-9]\d*)yr)?$/i;
+var ADULT_BAND = /^(?:adults?|ad)[\s-]+(\S.*)$/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]
+    };
+  if (ladder.ranges.some(([c, d]) => (c !== a || d !== b) && c < b && a < d))
+    return {
+      kind: "range",
+      interval: null,
+      refusal: "overlapping-ranges",
+      clauses: ["range-overlapping"],
+      parts: [a, b]
+    };
+  const below = maxWhere(ladder.caps, (c) => c < b);
+  const adultFloor = below === undefined && ladder.adult === true && b > ADULT_FLOOR2;
+  const meetsOver = ladder.overs.includes(b + 1) && !ladder.caps.some((c) => c > b);
+  const clauses = [
+    "range-as-under",
+    below !== undefined ? "under-floored-on-rung" : adultFloor ? "range-adult-floor" : "youngest-absorbs"
+  ];
+  if (meetsOver)
+    clauses.push("range-top-meets-over");
+  return {
+    kind: "range",
+    interval: {
+      lo: below ?? (adultFloor ? ADULT_FLOOR2 : YOUNGEST_FLOOR2),
+      hi: meetsOver ? b + 1 : b
+    },
+    refusal: null,
+    clauses,
+    parts: [a, b]
+  };
+}
+function strideOf(k) {
+  if (k === undefined)
+    return null;
+  const n = Number(k);
+  return Number.isInteger(n) && n >= 1 ? n : null;
+}
+function read(token, ladder, top) {
+  const r = RANGE2.exec(token);
+  if (r !== null)
+    return readRange(Number(r[1]), Number(r[2]), ladder);
+  const au = ADULT_UNDER.exec(token);
+  if (au !== null && Number(au[1]) > ADULT_FLOOR2) {
+    const k = strideOf(au[2]);
+    const hi = Number(au[1]);
+    return {
+      kind: "adult",
+      interval: { lo: k === null ? ADULT_FLOOR2 : Math.max(ADULT_FLOOR2, hi - k), hi },
+      refusal: null,
+      clauses: k === null ? ["adult-under-ceiling"] : ["adult-under-ceiling", "under-stride"],
+      parts: k === null ? [hi] : [hi, k]
+    };
+  }
+  const ab = au === null ? ADULT_BAND.exec(token) : null;
+  if (ab !== null) {
+    const inner = read(ab[1].trim(), { ...ladder, adult: true }, top);
+    if (inner.kind === "over" || inner.kind === "range")
+      return { ...inner, clauses: [...inner.clauses, "adult-band"], adult: true };
+  }
+  if (au !== null || ADULT_WORD.test(token))
+    return {
+      kind: "adult",
+      interval: { lo: ADULT_FLOOR2, 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 = UNDER2.exec(token);
+  if (u !== null) {
+    const n = Number(u[1]);
+    const k = strideOf(u[2]);
+    if (k !== null)
+      return {
+        kind: "under",
+        interval: { lo: Math.max(YOUNGEST_FLOOR2, n - k), hi: n },
+        refusal: null,
+        clauses: ["under-stride"],
+        parts: [n, k]
+      };
+    const below = maxWhere(ladder.caps, (c) => c < n);
+    return {
+      kind: "under",
+      interval: { lo: below ?? YOUNGEST_FLOOR2, hi: n },
+      refusal: null,
+      clauses: [below === undefined ? "youngest-absorbs" : "under-floored-on-rung"],
+      parts: [n]
+    };
+  }
+  const o = OVER.exec(token) ?? AND_OVER2.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: [] };
+}
+function refuseBelowYoungest(r) {
+  if (r.interval === null || r.interval.hi >= YOUNGEST_BAND_TOP2)
+    return r;
+  return { ...r, interval: null, refusal: "below-youngest-band", clauses: [] };
+}
+
+class AgeMisuseError2 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 (isAveraged2(container))
+        throw new AgeMisuseError2("average-as-container", `${self.ag2} cannot fit inside an average age (${String(container)}); an average is not a dancer`);
+      const r = ageRelation2(self, container);
+      return r.relation === "same" || r.reason === "b-contains-a";
+    },
+    overlaps: (other) => {
+      const r = ageRelation2(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: [] } : refuseBelowYoungest(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,
+    ...validity(arm === "empty", reading.refusal),
+    source,
+    clauses: reading.clauses,
+    ladder,
+    year,
+    isAge: () => iv !== null,
+    isExact: () => {
+      if (iv === null || year === null)
+        return false;
+      const b = birthYearsOfInterval2(iv, year);
+      return b.from !== null && b.from === b.to;
+    },
+    isAndOver: () => iv !== null && iv.hi === Number.POSITIVE_INFINITY,
+    isAdult: () => reading.kind === "adult" || reading.adult === true,
+    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 birthYearsOfInterval2(iv, at);
+    },
+    floorObserved: () => reading.kind !== "under" && reading.kind !== "range" || iv === null ? null : reading.clauses.includes("under-floored-on-rung") || reading.clauses.includes("range-adult-floor") || reading.clauses.includes("under-stride")
+  });
+}
+function fromYOB(from, to = from, context = {}) {
+  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 at = context.year ?? null;
+  const valid = [from, to].every((y) => y === null || y >= YOB_RANGE2.first && y <= YOB_RANGE2.last) && (at === null || to === null || yearsSinceBirth2(at, to) >= YOUNG_FLOOR2.hard);
+  const refusal = valid ? null : "year-out-of-range";
+  const exact = valid && from !== null && from === to;
+  const ag0 = from !== null && from === to ? String(from) : `${from ?? ""}..${to ?? ""}`;
+  const ag2 = valid ? `b${ag0}` : `b${ag0}?`;
+  const years = Object.freeze(valid ? { from, to } : { from: null, to: null });
+  return withRelations({
+    [Symbol.toStringTag]: "Age",
+    toString: () => ag2,
+    arm: valid ? "yob" : "open",
+    kind: "yob",
+    ag0,
+    ag1: ag0,
+    ag2,
+    parts: from !== null && from === to ? [from] : [from, to].filter((y) => y !== null),
+    length: ag2.length,
+    refusal,
+    ...validity(false, refusal),
+    source: valid ? "printed-yob" : "open",
+    clauses: [],
+    ladder: NO_LADDER,
+    year: null,
+    isAge: () => valid,
+    isExact: () => exact,
+    isAndOver: () => valid && from === null,
+    isAdult: () => false,
+    interval: () => null,
+    birthYears: () => years,
+    floorObserved: () => null
+  });
+}
+function fromTitle(title, context = {}) {
+  const t = ageTitleToken2(title);
+  return Object.freeze({ age: fromPrint(t.token, context), token: t.token, span: t.span });
+}
+var Age2 = Object.freeze({ from: fromPrint, fromYOB, fromTitle });
+function sourceOf(r) {
+  const iv = r.interval;
+  if (iv === null)
+    return "open";
+  switch (r.kind) {
+    case "range":
+    case "under":
+      if (r.clauses.includes("under-stride"))
+        return "printed-band";
+      return iv.lo > YOUNGEST_FLOOR2 ? "sibling-narrowed" : "printed-band";
+    case "over":
+      return iv.hi === Number.POSITIVE_INFINITY ? "printed-band" : "sibling-narrowed";
+    case "adult":
+    case "senior":
+      return "printed-band";
+    default:
+      return "open";
+  }
+}
+function birthYearsOfInterval2(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_YEARS2)
+  };
+}
+var inBirthYears = (a) => a.kind === "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 ageRelation2(a, b) {
+  for (const x of [a, b])
+    if (isAveraged2(x))
+      throw new AgeMisuseError2("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 canOverlap2(...ages) {
+  for (let i = 0;i < ages.length; i++)
+    for (let j = i + 1;j < ages.length; j++)
+      if (ageRelation2(ages[i], ages[j]).relation === "disjoint")
+        return false;
+  return true;
+}
+var AVERAGE_AGE_DECIMALS2 = 2;
+var HUNDREDTHS = 10 ** AVERAGE_AGE_DECIMALS2;
+function roundedMeanHundredths2(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 isAveraged2(a) {
+  return a[Symbol.toStringTag] === "AverageAge";
+}
+function averageAge2(ages) {
+  if (ages.length === 0)
+    throw new AgeMisuseError2("empty-average", "averageAge needs at least one exact age");
+  let sum = 0;
+  for (const [i, a] of ages.entries()) {
+    if (isAveraged2(a))
+      throw new AgeMisuseError2("average-of-averages", `input ${i} (${String(a)}) is already an average; average the members instead`);
+    if (!a.isExact())
+      throw new AgeMisuseError2("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) => roundedMeanHundredths2(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 (isAveraged2(container))
+        throw new AgeMisuseError2("average-as-container", `nothing fits inside an average age (${String(container)})`);
+      if (container.year === null)
+        throw new AgeMisuseError2("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 AgeMisuseError2("average-birth-years", `an average of ${n} has no year of birth; read meanBirthYear, which is not a dancer's`);
+    }
+  };
+  return self;
+}
+function birthYearsDisjoint2(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 intersectBirthYears2(windows) {
+  let from = null;
+  let to = null;
+  let n = 0;
+  for (const w of windows) {
+    if (w.from === null && w.to === null)
+      continue;
+    n++;
+    if (w.from !== null)
+      from = from === null ? w.from : Math.max(from, w.from);
+    if (w.to !== null)
+      to = to === null ? w.to : Math.min(to, w.to);
+  }
+  if (n === 0)
+    return { from: null, to: null, n: 0 };
+  if (from !== null && to !== null && from > to)
+    return null;
+  return { from, to, n };
+}
+function birthYearsMeet2(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 underCapApplies2(bandFrom, year) {
+  return bandFrom !== null && year - bandFrom <= UNDER_CAP_MAX_TOP2;
+}
+function underCappedYears2(b, year, n = UNDER_CAP2.plain) {
+  if (n > UNDER_CAP2.exceptional)
+    throw new Error(`under-cap: ${n} is over the exceptional cap of ${UNDER_CAP2.exceptional}`);
+  if (!underCapApplies2(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 underCapRefuses2(bandFrom, identityFrom, n) {
+  return identityFrom > bandFrom + n;
+}
+function validYOB2(y, year) {
+  if (y === null || y === undefined || !Number.isInteger(y))
+    return null;
+  return Age2.fromYOB(y, y, { year: year ?? null }).isValid() ? y : null;
+}
+function youngFloor2(year, oldest) {
+  const s = yearsSinceBirth2(year, oldest);
+  if (s >= YOUNG_FLOOR2.soft)
+    return "clear";
+  if (s < YOUNG_FLOOR2.hard)
+    return "too-young";
+  return "same-school-only";
+}
+var tooYoungForMajor2 = (year, oldest) => yearsSinceBirth2(year, oldest) < MIN_MAJOR_AGE2;
+var tooYoungForFeis2 = (year, oldest) => yearsSinceBirth2(year, oldest) < MIN_FEIS_AGE2;
+
+export { TITLE_RANGE_MIN2, TITLE_RANGE_MAX2, ageTitleToken2, adultBeside2, YOUNGEST_FLOOR2, ADULT_FLOOR2, MAJORS_FLOOR_YEARS2, UNDER_CAP2, UNDER_CAP_MAX_TOP2, YOUNG_FLOOR2, MIN_MAJOR_AGE2, MIN_FEIS_AGE2, YOUNGEST_BAND_TOP2, YOB_RANGE2, DANCE_UP_YEARS2, ageOnJanuary12, yearsSinceBirth2, AgeMisuseError2, Age2, birthYearsOfInterval2, ageRelation2, canOverlap2, AVERAGE_AGE_DECIMALS2, roundedMeanHundredths2, isAveraged2, averageAge2, birthYearsDisjoint2, intersectBirthYears2, birthYearsMeet2, underCapApplies2, underCappedYears2, underCapRefuses2, validYOB2, youngFloor2, tooYoungForMajor2, tooYoungForFeis2 };